InitializeComponent for multiple assembly versions (WPF)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")]
public void InitializeComponent() {
    if (_contentLoaded) {
        return;
    }
    _contentLoaded = true;
    System.Uri resourceLocater = new System.Uri("/MyLibrary;component/MyView.xaml", System.UriKind.Relative);
     
    #line 1 "..\..\MyView.xaml"
    System.Windows.Application.LoadComponent(this, resourceLocater);
     
    #line default
    #line hidden
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

private void GenerateInitializeComponent(bool isApp)
{
    // public void InitializeComponent()
    // {
    //
    CodeMemberMethod cmmLC = _ccRoot.InitializeComponentFn;

    if (cmmLC == null)
    {
        cmmLC = _ccRoot.EnsureInitializeComponentFn;
        if (!isApp)
        {
            cmmLC.ImplementationTypes.Add(new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector]));
        }
    }

    //     if (_contentLoaded)
    //     {
    //         return;
    //     }
    //
    CodeConditionStatement ccsCL = new CodeConditionStatement();
    ccsCL.Condition = new CodeFieldReferenceExpression(null, CONTENT_LOADED);
    ccsCL.TrueStatements.Add(new CodeMethodReturnStatement());
    if (!isApp)
    {
        cmmLC.Statements.Add(ccsCL);
    }
    else
    {
        cmmLC.Statements.Insert(0, ccsCL);
    }

    //     _contentLoaded = true;
    //
    CodeAssignStatement casCL = new CodeAssignStatement(new CodeFieldReferenceExpression(null, CONTENT_LOADED),
                                                        new CodePrimitiveExpression(true));
    if (!isApp)
    {
        cmmLC.Statements.Add(casCL);
    }
    else
    {
        cmmLC.Statements.Insert(1, casCL);
    }

    // Generate canonicalized string as resource id.
    bool requestExtensionChange = false;
    string resourceID = ResourcesGenerator.GetResourceIdForResourceFile(
            SourceFileInfo.RelativeSourceFilePath + XAML,
            SourceFileInfo.OriginalFileLinkAlias,
            SourceFileInfo.OriginalFileLogicalName,
            TargetPath,
            Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar,
            requestExtensionChange);

    string uriPart = string.Empty;

    // Attempt to parse out the AssemblyVersion if it exists.  This validates that we can either use an empty version string (wildcards exist)
    // or we can utilize the passed in string (valid parse).
    if (!VersionHelper.TryParseAssemblyVersion(AssemblyVersion, allowWildcard: true, version: out _, out bool hasWildcard)
        && !string.IsNullOrWhiteSpace(AssemblyVersion))
    {
        throw new AssemblyVersionParseException(SR.Get(SRID.InvalidAssemblyVersion, AssemblyVersion));
    }

    // In .NET Framework (non-SDK-style projects), the process to use a wildcard AssemblyVersion is to do the following:
    //   - Modify the AssemblyVersionAttribute to a wildcard string (e.g. "1.2.*")
    //   - Set Deterministic to false in the build
    // During MarkupCompilation, the AssemblyVersion property would not be set and WPF would correctly generate a resource URI without a version.
    // In .NET Core/5 (or .NET Framework SDK-style projects), the same process can be used if GenerateAssemblyVersionAttribute is set to false in 
    // the build.  However, this isn't really the idiomatic way to set the version for an assembly.  Instead, developers are more likely to use the 
    // AssemblyVersion build property.  If a developer explicitly sets the AssemblyVersion build property to a wildcard version string, we would use 
    // that as part of the URI here.  This results in an error in Version.Parse during InitializeComponent's call tree.  Instead, do as we would have 
    // when the developer sets a wildcard version string via AssemblyVersionAttribute and use an empty string.
    string version = hasWildcard || String.IsNullOrEmpty(AssemblyVersion)
        ? String.Empty
        : COMPONENT_DELIMITER + VER + AssemblyVersion;

    string token = String.IsNullOrEmpty(AssemblyPublicKeyToken)
        ? String.Empty
        : COMPONENT_DELIMITER + AssemblyPublicKeyToken;

    uriPart = FORWARDSLASH + AssemblyName + version + token + COMPONENT_DELIMITER + COMPONENT + FORWARDSLASH + resourceID;

    //
    //  Uri resourceLocator = new Uri(uriPart, UriKind.Relative);
    //
    string resVarname = RESOURCE_LOCATER;

    CodeFieldReferenceExpression cfreRelUri = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.UriKind)), "Relative");

    CodeExpression[] uriParams = { new CodePrimitiveExpression(uriPart), cfreRelUri };
    CodeObjectCreateExpression coceResourceLocator = new CodeObjectCreateExpression(typeof(System.Uri), uriParams);
    CodeVariableDeclarationStatement cvdsresLocator = new CodeVariableDeclarationStatement(typeof(System.Uri), resVarname, coceResourceLocator);

    cmmLC.Statements.Add(cvdsresLocator);

    //
    //  System.Windows.Application.LoadComponent(this, resourceLocator);
    //
    CodeMethodReferenceExpression cmreLoadContent = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(KnownTypes.Types[(int)KnownElements.Application]), LOADCOMPONENT);
    CodeMethodInvokeExpression cmieLoadContent = new CodeMethodInvokeExpression();

    cmieLoadContent.Method = cmreLoadContent;

    CodeVariableReferenceExpression cvreMemStm = new CodeVariableReferenceExpression(resVarname);

    cmieLoadContent.Parameters.Add(new CodeThisReferenceExpression());
    cmieLoadContent.Parameters.Add(cvreMemStm);

    CodeExpressionStatement cesLC = new CodeExpressionStatement(cmieLoadContent);
    AddLinePragma(cesLC, 1);
    cmmLC.Statements.Add(cesLC);

    // private bool _contentLoaded;
    //
    CodeMemberField cmfCL = new CodeMemberField();
    cmfCL.Name = CONTENT_LOADED;
    cmfCL.Attributes = MemberAttributes.Private;
    cmfCL.Type = new CodeTypeReference(typeof(bool));
    _ccRoot.CodeClass.Members.Add(cmfCL);

    if (!isApp)
    {
        // Make sure that ICC.Connect is generated to avoid compilation errors
        EnsureHookupFn();
    }
}