diff --git a/DotNetWorker.sln b/DotNetWorker.sln
index 76950c9d7..7047b1597 100644
--- a/DotNetWorker.sln
+++ b/DotNetWorker.sln
@@ -138,6 +138,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Worker.Extensions.Http.AspN
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Worker.Extensions.Http.AspNetCore.Analyzers", "extensions\Worker.Extensions.Http.AspNetCore.Analyzers\Worker.Extensions.Http.AspNetCore.Analyzers.csproj", "{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DependentAssemblyWithFunctions.NetStandard", "test\DependentAssemblyWithFunctions.NetStandard\DependentAssemblyWithFunctions.NetStandard.csproj", "{198DA072-F94F-4585-A744-97B3DAC21686}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -336,14 +338,18 @@ Global
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753}.Release|Any CPU.Build.0 = Release|Any CPU
-		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{198DA072-F94F-4585-A744-97B3DAC21686}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{198DA072-F94F-4585-A744-97B3DAC21686}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{198DA072-F94F-4585-A744-97B3DAC21686}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{198DA072-F94F-4585-A744-97B3DAC21686}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -404,6 +410,7 @@ Global
 		{AB6E1E7A-0D2C-4086-9487-566887C1E753} = {B5821230-6E0A-4535-88A9-ED31B6F07596}
 		{D8E79B53-9A44-46CC-9D7A-E9494FC8CAF4} = {AA4D318D-101B-49E7-A4EC-B34165AEDB33}
 		{7B6C2920-7A02-43B2-8DA0-7B76B9FAFC6B} = {A7B4FF1E-3DF7-4F28-9333-D0961CDDF702}
+		{198DA072-F94F-4585-A744-97B3DAC21686} = {B5821230-6E0A-4535-88A9-ED31B6F07596}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {497D2ED4-A13E-4BCA-8D29-F30CA7D0EA4A}
diff --git a/sdk/Sdk.Generators/Constants.cs b/sdk/Sdk.Generators/Constants.cs
index c64b01633..68a25a127 100644
--- a/sdk/Sdk.Generators/Constants.cs
+++ b/sdk/Sdk.Generators/Constants.cs
@@ -12,6 +12,7 @@ internal static class Languages
 
         internal static class BuildProperties
         {
+            internal const string MSBuildTargetFrameworkIdentifier = "build_property.TargetFrameworkIdentifier";
             internal const string MSBuildRootNamespace = "build_property.RootNamespace";
             internal const string GeneratedCodeNamespace = "build_property.FunctionsGeneratedCodeNamespace";
             internal const string EnableSourceGen = "build_property.FunctionsEnableMetadataSourceGen";
diff --git a/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.Parser.cs b/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.Parser.cs
index ebf9c0ce7..d939f8616 100644
--- a/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.Parser.cs
+++ b/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.Parser.cs
@@ -40,7 +40,8 @@ public Parser(GeneratorExecutionContext context)
             /// Takes in candidate methods from the user compilation and parses them to return function metadata info as GeneratorFunctionMetadata.
             /// </summary>
             /// <param name="methods">List of candidate methods from the syntax receiver.</param>
-            public IReadOnlyList<GeneratorFunctionMetadata> GetFunctionMetadataInfo(List<IMethodSymbol> methods)
+            /// <param name="parsingContext">An instance of <see cref="FunctionsMetadataParsingContext"/>. Optional.</param>
+            public IReadOnlyList<GeneratorFunctionMetadata> GetFunctionMetadataInfo(List<IMethodSymbol> methods, FunctionsMetadataParsingContext? parsingContext = null)
             {
                 var result = ImmutableArray.CreateBuilder<GeneratorFunctionMetadata>();
 
@@ -49,14 +50,13 @@ public IReadOnlyList<GeneratorFunctionMetadata> GetFunctionMetadataInfo(List<IMe
                 {
                     CancellationToken.ThrowIfCancellationRequested();
 
-                    string? funcName = null;
-                    if (!FunctionsUtil.TryGetFunctionName(method, Compilation, out funcName))
+                    if (!FunctionsUtil.TryGetFunctionName(method, Compilation, out var funcName))
                     {
                         _context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SymbolNotFound, Location.None, method.Name)); // would only reach here if the function attribute or method was not loaded, resulting in failure to retrieve name
                     }
 
                     var assemblyName = method.ContainingAssembly.Name;
-                    var scriptFile = Path.Combine(assemblyName + ".dll");
+                    var scriptFile = $"{assemblyName}{parsingContext?.ScriptFileExtension ?? ".dll"}";
 
                     var newFunction = new GeneratorFunctionMetadata
                     {
diff --git a/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.cs b/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.cs
index 7bcafdbf8..11736adf8 100644
--- a/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.cs
+++ b/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.cs
@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -18,6 +19,10 @@ namespace Microsoft.Azure.Functions.Worker.Sdk.Generators
     [Generator]
     public partial class FunctionMetadataProviderGenerator : ISourceGenerator
     {
+        private const string NetFxTargetFrameworkIdentifierValue = ".NETFramework";
+        private const string ExecutableFileExtension = ".exe";
+        private const string DynamicLinkLibraryFileExtension = ".dll";
+
         public void Execute(GeneratorExecutionContext context)
         {
             if (context.SyntaxReceiver is not FunctionMethodSyntaxReceiver receiver || receiver.CandidateMethods.Count == 0)
@@ -37,10 +42,17 @@ public void Execute(GeneratorExecutionContext context)
             // attempt to parse user compilation
             var p = new Parser(context);
 
-            var entryAssemblyFuncs = GetEntryAssemblyFunctions(receiver.CandidateMethods, context);
-            var dependentFuncs = GetDependentAssemblyFunctions(context);
+            var entryAssemblyFunctionSymbols = GetEntryAssemblyFunctions(receiver.CandidateMethods, context);
+            var dependentAssemblyFunctionSymbols = GetDependentAssemblyFunctions(context);
+
+            var entryAssemblyParsingContext = new FunctionsMetadataParsingContext
+            {
+                ScriptFileExtension = GetScriptFileExtensionForEntryPointAssemblyFunctions(context)
+            };
+            var entryAssemblyFunctions = p.GetFunctionMetadataInfo(entryAssemblyFunctionSymbols.ToList(), entryAssemblyParsingContext);
+            var dependentAssemblyFunctions = p.GetFunctionMetadataInfo(dependentAssemblyFunctionSymbols.ToList());
 
-            IReadOnlyList<GeneratorFunctionMetadata> functionMetadataInfo = p.GetFunctionMetadataInfo(entryAssemblyFuncs.Concat(dependentFuncs).ToList());
+            IReadOnlyList<GeneratorFunctionMetadata> functionMetadataInfo = entryAssemblyFunctions.Concat(dependentAssemblyFunctions).ToList();
 
             // Proceed to generate the file if function metadata info was successfully returned
             if (functionMetadataInfo.Count > 0)
@@ -63,6 +75,14 @@ public void Initialize(GeneratorInitializationContext context)
             context.RegisterForSyntaxNotifications(() => new FunctionMethodSyntaxReceiver());
         }
 
+        // For dependent assemblies, it will be always "dll". We only need to find out for entry point assembly.
+        private static string GetScriptFileExtensionForEntryPointAssemblyFunctions(GeneratorExecutionContext context)
+        {
+            context.AnalyzerConfigOptions.GlobalOptions.TryGetValue(Constants.BuildProperties.MSBuildTargetFrameworkIdentifier, out var value);
+
+            return string.Equals(value, NetFxTargetFrameworkIdentifierValue, StringComparison.OrdinalIgnoreCase) ? ExecutableFileExtension : DynamicLinkLibraryFileExtension;
+        }
+
         private static bool ShouldIncludeAutoGeneratedAttributes(GeneratorExecutionContext context)
         {
             if (!context.AnalyzerConfigOptions.GlobalOptions.TryGetValue(
diff --git a/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionsMetadataParsingContext.cs b/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionsMetadataParsingContext.cs
new file mode 100644
index 000000000..93fcbeb6b
--- /dev/null
+++ b/sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionsMetadataParsingContext.cs
@@ -0,0 +1,10 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.;
+
+namespace Microsoft.Azure.Functions.Worker.Sdk.Generators
+{
+    internal sealed class FunctionsMetadataParsingContext
+    {
+        internal string? ScriptFileExtension { get; set; }
+    }
+}
diff --git a/sdk/Sdk/Targets/Microsoft.Azure.Functions.Worker.Sdk.props b/sdk/Sdk/Targets/Microsoft.Azure.Functions.Worker.Sdk.props
index d24ff04fb..d7e98339a 100644
--- a/sdk/Sdk/Targets/Microsoft.Azure.Functions.Worker.Sdk.props
+++ b/sdk/Sdk/Targets/Microsoft.Azure.Functions.Worker.Sdk.props
@@ -26,6 +26,7 @@ WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and
     <CompilerVisibleProperty Include="FunctionsAutoRegisterGeneratedFunctionsExecutor" />
     <CompilerVisibleProperty Include="FunctionsAutoRegisterGeneratedMetadataProvider" />
     <CompilerVisibleProperty Include="FunctionsGeneratedCodeNamespace" />
+    <CompilerVisibleProperty Include="TargetFrameworkIdentifier" />
   </ItemGroup>
 <!--
   ***********************************************************************************************
diff --git a/sdk/release_notes.md b/sdk/release_notes.md
index b9efdf82b..541bb6809 100644
--- a/sdk/release_notes.md
+++ b/sdk/release_notes.md
@@ -11,5 +11,6 @@
 
 ### Microsoft.Azure.Functions.Worker.Sdk.Generators 1.1.5
 - Update worker.config generation to accurate worker executable name (#1053)
+- Fix incorrect value of `ScriptFile` property in function metadata for .Net Framework function apps (#2103)
 - Generate valid namespace when root namespace contains `-` (#2097)
-- Bug fix for scenarios with `$return` output binding and `HttpTrigger` breaking output-binding rules (#2098)
+- Bug fix for scenarios with `$return` output binding and `HttpTrigger` breaking output-binding rules (#2098)
\ No newline at end of file
diff --git a/test/DependentAssemblyWithFunctions.NetStandard/DependentAssemblyWithFunctions.NetStandard.csproj b/test/DependentAssemblyWithFunctions.NetStandard/DependentAssemblyWithFunctions.NetStandard.csproj
new file mode 100644
index 000000000..77009bcc2
--- /dev/null
+++ b/test/DependentAssemblyWithFunctions.NetStandard/DependentAssemblyWithFunctions.NetStandard.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.19.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.0.13" />
+  </ItemGroup>
+</Project>
diff --git a/test/DependentAssemblyWithFunctions.NetStandard/NetStandardClassLibraryClass1.cs b/test/DependentAssemblyWithFunctions.NetStandard/NetStandardClassLibraryClass1.cs
new file mode 100644
index 000000000..276880c08
--- /dev/null
+++ b/test/DependentAssemblyWithFunctions.NetStandard/NetStandardClassLibraryClass1.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Extensions.Logging;
+
+namespace DependentAssemblyWithFunctions.NetStandard
+{
+    public sealed class NetStandardClassLibraryClass1
+    {
+        private readonly ILogger _logger;
+
+        public NetStandardClassLibraryClass1(ILoggerFactory loggerFactory)
+        {
+            _logger = loggerFactory.CreateLogger<NetStandardClassLibraryClass1>();
+        }
+
+        [Function("NetStandardClassLibraryClass1Function1")]
+        public HttpResponseData Run1([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req)
+        {
+            _logger.LogInformation("NetStandardClassLibraryClass1Function1");
+            throw new NotImplementedException();
+        }
+
+        [Function("NetStandardClassLibraryClass1Function2Async")]
+        public Task<HttpResponseData> Run2([HttpTrigger(AuthorizationLevel.Admin, "get", "post")] HttpRequestData req)
+        {
+            _logger.LogInformation("NetStandardClassLibraryClass1Function2Async");
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/test/Sdk.Generator.Tests/FunctionMetadataProviderGeneratorTests/DependentAssemblyTest.NetFx.cs b/test/Sdk.Generator.Tests/FunctionMetadataProviderGeneratorTests/DependentAssemblyTest.NetFx.cs
new file mode 100644
index 000000000..1e38b7813
--- /dev/null
+++ b/test/Sdk.Generator.Tests/FunctionMetadataProviderGeneratorTests/DependentAssemblyTest.NetFx.cs
@@ -0,0 +1,166 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.Azure.Functions.Worker.Sdk.Generators;
+using Xunit;
+
+namespace Microsoft.Azure.Functions.SdkGeneratorTests
+{
+    public partial class FunctionMetadataProviderGeneratorTests
+    {
+        public class DependentAssemblyTestNetFx
+        {
+            private readonly Assembly[] _referencedExtensionAssemblies;
+
+            public DependentAssemblyTestNetFx()
+            {
+                // load all extensions used in tests (match extensions tested on E2E app? Or include ALL extensions?)
+                var abstractionsExtension = Assembly.LoadFrom("Microsoft.Azure.Functions.Worker.Extensions.Abstractions.dll");
+                var httpExtension = Assembly.LoadFrom("Microsoft.Azure.Functions.Worker.Extensions.Http.dll");
+                var hostingExtension = Assembly.LoadFrom("Microsoft.Extensions.Hosting.dll");
+                var diExtension = Assembly.LoadFrom("Microsoft.Extensions.DependencyInjection.dll");
+                var hostingAbExtension = Assembly.LoadFrom("Microsoft.Extensions.Hosting.Abstractions.dll");
+                var diAbExtension = Assembly.LoadFrom("Microsoft.Extensions.DependencyInjection.Abstractions.dll");
+                var dependentAssembly = Assembly.LoadFrom("DependentAssemblyWithFunctions.NetStandard.dll");
+
+                _referencedExtensionAssemblies = new[]
+                {
+                    abstractionsExtension,
+                    httpExtension,
+                    hostingExtension,
+                    hostingAbExtension,
+                    diExtension,
+                    diAbExtension,
+                    dependentAssembly
+                };
+            }
+
+            [Fact]
+            public async Task FunctionInDependentAssemblyTest()
+            {
+                string inputCode = """
+                using System;
+                using System.Collections.Generic;
+                using Microsoft.Azure.Functions.Worker;
+                using Microsoft.Azure.Functions.Worker.Http;
+
+                namespace FunctionApp
+                {
+                    public static class EntryPointAssemblyHttpFunctions
+                    {
+                        [Function(nameof(EntryPointAssemblyHttpFunctions))]
+                        public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req, FunctionContext executionContext)
+                        {
+                            throw new NotImplementedException();
+                        }
+                    }
+                }
+                """;
+
+                string expectedGeneratedFileName = $"GeneratedFunctionMetadataProvider.g.cs";
+                string expectedOutput = """
+                // <auto-generated/>
+                using System;
+                using System.Collections.Generic;
+                using System.Collections.Immutable;
+                using System.Text.Json;
+                using System.Threading.Tasks;
+                using Microsoft.Azure.Functions.Worker;
+                using Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
+                using Microsoft.Extensions.DependencyInjection;
+                using Microsoft.Extensions.Hosting;
+
+                namespace TestProject
+                {
+                    /// <summary>
+                    /// Custom <see cref="IFunctionMetadataProvider"/> implementation that returns function metadata definitions for the current worker."/>
+                    /// </summary>
+                    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+                    public class GeneratedFunctionMetadataProvider : IFunctionMetadataProvider
+                    {
+                        /// <inheritdoc/>
+                        public Task<ImmutableArray<IFunctionMetadata>> GetFunctionMetadataAsync(string directory)
+                        {
+                            var metadataList = new List<IFunctionMetadata>();
+                            var Function0RawBindings = new List<string>();
+                            Function0RawBindings.Add(@"{""name"":""req"",""type"":""httpTrigger"",""direction"":""In"",""authLevel"":""Anonymous"",""methods"":[""get"",""post""]}");
+                            Function0RawBindings.Add(@"{""name"":""$return"",""type"":""http"",""direction"":""Out""}");
+
+                            var Function0 = new DefaultFunctionMetadata
+                            {
+                                Language = "dotnet-isolated",
+                                Name = "EntryPointAssemblyHttpFunctions",
+                                EntryPoint = "FunctionApp.EntryPointAssemblyHttpFunctions.Run",
+                                RawBindings = Function0RawBindings,
+                                ScriptFile = "TestProject.exe"
+                            };
+                            metadataList.Add(Function0);
+                            var Function1RawBindings = new List<string>();
+                            Function1RawBindings.Add(@"{""name"":""req"",""type"":""httpTrigger"",""direction"":""In"",""authLevel"":""Function"",""methods"":[""get"",""post""]}");
+                            Function1RawBindings.Add(@"{""name"":""$return"",""type"":""http"",""direction"":""Out""}");
+                
+                            var Function1 = new DefaultFunctionMetadata
+                            {
+                                Language = "dotnet-isolated",
+                                Name = "NetStandardClassLibraryClass1Function1",
+                                EntryPoint = "DependentAssemblyWithFunctions.NetStandard.NetStandardClassLibraryClass1.Run1",
+                                RawBindings = Function1RawBindings,
+                                ScriptFile = "DependentAssemblyWithFunctions.NetStandard.dll"
+                            };
+                            metadataList.Add(Function1);
+                            var Function2RawBindings = new List<string>();
+                            Function2RawBindings.Add(@"{""name"":""req"",""type"":""httpTrigger"",""direction"":""In"",""authLevel"":""Admin"",""methods"":[""get"",""post""]}");
+                            Function2RawBindings.Add(@"{""name"":""$return"",""type"":""http"",""direction"":""Out""}");
+                
+                            var Function2 = new DefaultFunctionMetadata
+                            {
+                                Language = "dotnet-isolated",
+                                Name = "NetStandardClassLibraryClass1Function2Async",
+                                EntryPoint = "DependentAssemblyWithFunctions.NetStandard.NetStandardClassLibraryClass1.Run2",
+                                RawBindings = Function2RawBindings,
+                                ScriptFile = "DependentAssemblyWithFunctions.NetStandard.dll"
+                            };
+                            metadataList.Add(Function2);
+
+                            return Task.FromResult(metadataList.ToImmutableArray());
+                        }
+                    }
+
+                    /// <summary>
+                    /// Extension methods to enable registration of the custom <see cref="IFunctionMetadataProvider"/> implementation generated for the current worker.
+                    /// </summary>
+                    public static class WorkerHostBuilderFunctionMetadataProviderExtension
+                    {
+                        ///<summary>
+                        /// Adds the GeneratedFunctionMetadataProvider to the service collection.
+                        /// During initialization, the worker will return generated function metadata instead of relying on the Azure Functions host for function indexing.
+                        ///</summary>
+                        public static IHostBuilder ConfigureGeneratedFunctionMetadataProvider(this IHostBuilder builder)
+                        {
+                            builder.ConfigureServices(s => 
+                            {
+                                s.AddSingleton<IFunctionMetadataProvider, GeneratedFunctionMetadataProvider>();
+                            });
+                            return builder;
+                        }
+                    }
+                }
+                """;
+
+                var buildPropertiesDict = new Dictionary<string, string>()
+                {
+                    {  Constants.BuildProperties.MSBuildTargetFrameworkIdentifier, ".NETFramework"}
+                };
+                await TestHelpers.RunTestAsync<FunctionMetadataProviderGenerator>(
+                    _referencedExtensionAssemblies,
+                    inputCode,
+                    expectedGeneratedFileName,
+                    expectedOutput,
+                    buildPropertiesDictionary: buildPropertiesDict);
+            }
+        }
+    }
+}
diff --git a/test/Sdk.Generator.Tests/Sdk.Generator.Tests.csproj b/test/Sdk.Generator.Tests/Sdk.Generator.Tests.csproj
index 838a3f7ea..8feb33d9a 100644
--- a/test/Sdk.Generator.Tests/Sdk.Generator.Tests.csproj
+++ b/test/Sdk.Generator.Tests/Sdk.Generator.Tests.csproj
@@ -36,6 +36,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\extensions\Worker.Extensions.Http\src\Worker.Extensions.Http.csproj" />
     <ProjectReference Include="..\..\sdk\Sdk.Generators\Sdk.Generators.csproj" />
+    <ProjectReference Include="..\DependentAssemblyWithFunctions.NetStandard\DependentAssemblyWithFunctions.NetStandard.csproj" />
     <ProjectReference Include="..\Worker.Extensions.Sample-IncorrectImplementation\Worker.Extensions.Sample-IncorrectImplementation.csproj" />
     <ProjectReference Include="..\Worker.Extensions.Sample\Worker.Extensions.Sample.csproj" />
     <ProjectReference Include="..\..\extensions\Worker.Extensions.Storage\src\Worker.Extensions.Storage.csproj" />