language stringclasses 1 value | repo stringclasses 133 values | path stringlengths 13 229 | class_span dict | source stringlengths 14 2.92M | target stringlengths 1 153 |
|---|---|---|---|---|---|
csharp | cake-build__cake | src/Cake/Infrastructure/Composition/ModuleSearcher.cs | {
"start": 629,
"end": 1172
} | public interface ____
{
/// <summary>
/// Finds module types in the specified directory.
/// </summary>
/// <param name="root">The root directory.</param>
/// <param name="configuration">The Cake configuration.</param>
/// <returns>A collection of module types.</returns>
ICollection<Type> FindModuleTypes(DirectoryPath root, ICakeConfiguration configuration);
}
/// <summary>
/// Represents a module searcher for finding Cake modules.
/// </summary>
| IModuleSearcher |
csharp | xunit__xunit | src/xunit.v1.tests/xunit/Sdk/Utilities/TypeUtilityTests.cs | {
"start": 2366,
"end": 2482
} | internal class ____
{
public void NonTestMethod() { }
}
[RunWith(typeof(StubRunner))]
| ClassWithNoTestMethods |
csharp | dotnet__aspnetcore | src/Mvc/test/WebSites/HtmlGenerationWebSite/Models/ViewModel.cs | {
"start": 180,
"end": 379
} | public class ____
{
public int Integer { get; set; } = 23;
public long? NullableLong { get; set; } = 24L;
public TemplateModel Template { get; set; } = new SuperTemplateModel();
}
| ViewModel |
csharp | microsoft__semantic-kernel | dotnet/src/Connectors/Connectors.Google/GeminiToolCallBehavior.cs | {
"start": 440,
"end": 6661
} | class ____ be extended to support additional kinds of tools, including composite ones:
// the GeminiPromptExecutionSettings has a single ToolCallBehavior property, but we could
// expose a `public static ToolCallBehavior Composite(params ToolCallBehavior[] behaviors)`
// or the like to allow multiple distinct tools to be provided, should that be appropriate.
// We can also consider additional forms of tools, such as ones that dynamically examine
// the Kernel, KernelArguments, etc., and dynamically contribute tools to the ChatCompletionsOptions.
/// <summary>
/// The default maximum number of tool-call auto-invokes that can be made in a single request.
/// </summary>
/// <remarks>
/// After this number of iterations as part of a single user request is reached, auto-invocation
/// will be disabled (e.g. <see cref="AutoInvokeKernelFunctions"/> will behave like <see cref="EnableKernelFunctions"/>)).
/// This is a safeguard against possible runaway execution if the model routinely re-requests
/// the same function over and over. It is currently hardcoded, but in the future it could
/// be made configurable by the developer. Other configuration is also possible in the future,
/// such as a delegate on the instance that can be invoked upon function call failure (e.g. failure
/// to find the requested function, failure to invoke the function, etc.), with behaviors for
/// what to do in such a case, e.g. respond to the model telling it to try again. With parallel tool call
/// support, where the model can request multiple tools in a single response, it is significantly
/// less likely that this limit is reached, as most of the time only a single request is needed.
/// </remarks>
private const int DefaultMaximumAutoInvokeAttempts = 128;
/// <summary>
/// Gets an instance that will provide all of the <see cref="Kernel"/>'s plugins' function information.
/// Function call requests from the model will be propagated back to the caller.
/// </summary>
/// <remarks>
/// If no <see cref="Kernel"/> is available, no function information will be provided to the model.
/// </remarks>
public static GeminiToolCallBehavior EnableKernelFunctions => new KernelFunctions(autoInvoke: false);
/// <summary>
/// Gets an instance that will both provide all of the <see cref="Kernel"/>'s plugins' function information
/// to the model and attempt to automatically handle any function call requests.
/// </summary>
/// <remarks>
/// When successful, tool call requests from the model become an implementation detail, with the service
/// handling invoking any requested functions and supplying the results back to the model.
/// If no <see cref="Kernel"/> is available, no function information will be provided to the model.
/// </remarks>
public static GeminiToolCallBehavior AutoInvokeKernelFunctions => new KernelFunctions(autoInvoke: true);
/// <summary>Gets an instance that will provide the specified list of functions to the model.</summary>
/// <param name="functions">The functions that should be made available to the model.</param>
/// <param name="autoInvoke">true to attempt to automatically handle function call requests; otherwise, false.</param>
/// <returns>
/// The <see cref="GeminiToolCallBehavior"/> that may be set into <see cref="GeminiToolCallBehavior"/>
/// to indicate that the specified functions should be made available to the model.
/// </returns>
public static GeminiToolCallBehavior EnableFunctions(IEnumerable<GeminiFunction> functions, bool autoInvoke = false)
{
Verify.NotNull(functions);
return new EnabledFunctions(functions, autoInvoke);
}
/// <summary>Initializes the instance; prevents external instantiation.</summary>
private GeminiToolCallBehavior(bool autoInvoke)
{
this.MaximumAutoInvokeAttempts = autoInvoke ? DefaultMaximumAutoInvokeAttempts : 0;
}
/// <summary>Gets how many requests are part of a single interaction should include this tool in the request.</summary>
/// <remarks>
/// This should be greater than or equal to <see cref="MaximumAutoInvokeAttempts"/>. It defaults to <see cref="int.MaxValue"/>.
/// Once this limit is reached, the tools will no longer be included in subsequent retries as part of the operation, e.g.
/// if this is 1, the first request will include the tools, but the subsequent response sending back the tool's result
/// will not include the tools for further use.
/// </remarks>
public int MaximumUseAttempts { get; } = int.MaxValue;
/// <summary>Gets how many tool call request/response roundtrips are supported with auto-invocation.</summary>
/// <remarks>
/// To disable auto invocation, this can be set to 0.
/// </remarks>
public int MaximumAutoInvokeAttempts { get; }
/// <summary>
/// Gets whether validation against a specified list is required before allowing the model to request a function from the kernel.
/// </summary>
/// <value>true if it's ok to invoke any kernel function requested by the model if it's found;
/// false if a request needs to be validated against an allow list.</value>
internal virtual bool AllowAnyRequestedKernelFunction => false;
/// <summary>Configures the <paramref name="request"/> with any tools this <see cref="GeminiToolCallBehavior"/> provides.</summary>
/// <param name="kernel">The <see cref="Kernel"/> used for the operation.
/// This can be queried to determine what tools to provide into the <paramref name="request"/>.</param>
/// <param name="request">The destination <see cref="GeminiRequest"/> to configure.</param>
internal abstract void ConfigureGeminiRequest(Kernel? kernel, GeminiRequest request);
internal GeminiToolCallBehavior Clone()
{
return (GeminiToolCallBehavior)this.MemberwiseClone();
}
/// <summary>
/// Represents a <see cref="GeminiToolCallBehavior"/> that will provide to the model all available functions from a
/// <see cref="Kernel"/> provided by the client.
/// </summary>
| can |
csharp | dotnet__extensions | src/LegacySupport/PlatformAttributes/PlatformAttributes.cs | {
"start": 6913,
"end": 7120
} | internal sealed class ____ : OSPlatformAttribute
{
public UnsupportedOSPlatformGuardAttribute(string platformName) : base(platformName)
{
}
}
}
| UnsupportedOSPlatformGuardAttribute |
csharp | Xabaril__AspNetCore.Diagnostics.HealthChecks | src/HealthChecks.Network/SftpHealthCheck.cs | {
"start": 159,
"end": 2116
} | public class ____ : IHealthCheck
{
private readonly SftpHealthCheckOptions _options;
public SftpHealthCheck(SftpHealthCheckOptions options)
{
_options = Guard.ThrowIfNull(options);
}
/// <inheritdoc />
public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
List<string>? errorList = null;
foreach (var item in _options.ConfiguredHosts.Values)
{
var connectionInfo = new ConnectionInfo(item.Host, item.Port, item.UserName, item.AuthenticationMethods.ToArray());
if (context.Registration.Timeout > TimeSpan.Zero)
{
connectionInfo.Timeout = context.Registration.Timeout;
}
using var sftpClient = new SftpClient(connectionInfo);
sftpClient.Connect();
bool connectionSuccess = sftpClient.IsConnected && sftpClient.ConnectionInfo.IsAuthenticated;
if (connectionSuccess)
{
if (item.FileCreationOptions.createFile)
{
using var stream = new MemoryStream([0x0], 0, 1);
sftpClient.UploadFile(stream, item.FileCreationOptions.remoteFilePath);
}
}
else
{
(errorList ??= new()).Add($"Connection with sftp host {item.Host}:{item.Port} failed.");
if (!_options.CheckAllHosts)
{
break;
}
}
}
return Task.FromResult(errorList.GetHealthState(context));
}
catch (Exception ex)
{
return Task.FromResult(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
}
| SftpHealthCheck |
csharp | nuke-build__nuke | source/Nuke.Build/Execution/Extensions/HandleShellCompletionAttribute.cs | {
"start": 347,
"end": 2402
} | internal class ____ : BuildExtensionAttributeBase, IOnBuildCreated
{
public void OnBuildCreated(IReadOnlyCollection<ExecutableTarget> executableTargets)
{
if (BuildServerConfigurationGeneration.IsActive)
return;
if (IsLegacy(Build.RootDirectory))
{
Host.Error(
new[]
{
"The old-style .nuke configuration is no longer supported.",
"You can convert to the new-style .nuke directory by calling:",
" nuke :update"
}.JoinNewLine());
Environment.Exit(exitCode: -1);
}
else if (Build.BuildProjectFile != null)
{
var buildSchema = SchemaUtility.GetJsonString(Build);
var buildSchemaFile = GetBuildSchemaFile(Build.RootDirectory);
buildSchemaFile.WriteAllText(buildSchema);
var parametersFile = GetDefaultParametersFile(Build.RootDirectory);
if (!parametersFile.Exists())
{
parametersFile.WriteAllText($$"""
{
"$schema": "./{{BuildSchemaFileName}}"
}
""");
}
}
else if (ParameterService.GetPositionalArgument<string>(0) == ":complete")
{
var schema = SchemaUtility.GetJsonDocument(Build);
var profileNames = GetProfileNames(Build.RootDirectory);
var completionItems = CompletionUtility.GetItemsFromSchema(schema, profileNames);
var words = EnvironmentInfo.CommandLineArguments.Skip(2).JoinSpace();
var relevantCompletionItems = CompletionUtility.GetRelevantItems(words, completionItems);
foreach (var item in relevantCompletionItems)
Console.WriteLine(item);
Environment.Exit(exitCode: 0);
}
if (ParameterService.GetParameter<bool>(CompletionParameterName))
Environment.Exit(exitCode: 0);
}
}
| HandleShellCompletionAttribute |
csharp | OrchardCMS__OrchardCore | src/OrchardCore.Modules/OrchardCore.Deployment/Steps/JsonRecipeDeploymentStep.cs | {
"start": 134,
"end": 310
} | public class ____ : DeploymentStep
{
public JsonRecipeDeploymentStep()
{
Name = "JsonRecipe";
}
public string Json { get; set; }
}
| JsonRecipeDeploymentStep |
csharp | grandnode__grandnode2 | src/Web/Grand.Web.Vendor/Controllers/HomeController.cs | {
"start": 299,
"end": 3241
} | public class ____ : BaseVendorController
{
#region Ctor
public HomeController(
IContextAccessor contextAccessor,
ILogger<HomeController> logger,
IGrandAuthenticationService authenticationService)
{
_contextAccessor = contextAccessor;
_logger = logger;
_authenticationService = authenticationService;
}
#endregion
#region Fields
private readonly IContextAccessor _contextAccessor;
private readonly ILogger<HomeController> _logger;
private readonly IGrandAuthenticationService _authenticationService;
#endregion
#region Methods
public IActionResult Index()
{
return View();
}
public IActionResult Statistics()
{
return View();
}
public IActionResult AccessDenied()
{
_logger.LogInformation("Access denied to user #{CurrentCustomerEmail}", _contextAccessor.WorkContext.CurrentCustomer.Email);
return View();
}
public async Task<IActionResult> Logout()
{
await _authenticationService.SignOut();
return RedirectToRoute("VendorLogin");
}
[AcceptVerbs("Get")]
public async Task<IActionResult> GetStatesByCountryId(
[FromServices] ICountryService countryService,
[FromServices] ITranslationService translationService,
string countryId, bool? addSelectStateItem, bool? addAsterisk)
{
// This action method gets called via an ajax request
if (string.IsNullOrEmpty(countryId))
return Json(new List<dynamic>
{ new { id = "", name = translationService.GetResource("Address.SelectState") } });
var country = await countryService.GetCountryById(countryId);
var states = country != null ? country.StateProvinces.ToList() : new List<StateProvince>();
var result = (from s in states
select new { id = s.Id, name = s.Name }).ToList();
if (addAsterisk.HasValue && addAsterisk.Value)
{
//asterisk
result.Insert(0, new { id = "", name = "*" });
}
else
{
if (country == null)
{
//country is not selected ("choose country" item)
if (addSelectStateItem.HasValue && addSelectStateItem.Value)
result.Insert(0,
new { id = "", name = translationService.GetResource("Vendor.Address.SelectState") });
}
else
{
//some country is selected
if (result.Any())
//country has some states
if (addSelectStateItem.HasValue && addSelectStateItem.Value)
result.Insert(0,
new { id = "", name = translationService.GetResource("Vendor.Address.SelectState") });
}
}
return Json(result);
}
#endregion
} | HomeController |
csharp | unoplatform__uno | src/Uno.UI.Composition/Generated/3.0.0.0/Microsoft.UI.Composition/CompositionStrokeCap.cs | {
"start": 262,
"end": 809
} | public enum ____
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
Flat = 0,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
Square = 1,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
Round = 2,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
Triangle = 3,
#endif
}
#endif
}
| CompositionStrokeCap |
csharp | atata-framework__atata | src/Atata/WebDriver/Extensions/ClickableDelegate2Extensions.cs | {
"start": 19,
"end": 3992
} | public static class ____
{
public static Clickable<TNavigateTo, TOwner> GetControl<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
(Clickable<TNavigateTo, TOwner>)UIComponentResolver.GetControlByDelegate<TOwner>(clickable);
public static TOwner Click<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Click();
public static TOwner Hover<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Hover();
public static TOwner Focus<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Focus();
public static TOwner DoubleClick<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().DoubleClick();
public static TOwner RightClick<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().RightClick();
public static TOwner ScrollTo<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().ScrollTo();
public static bool IsEnabled<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().IsEnabled;
public static bool Exists<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable, SearchOptions? options = null)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Exists(options);
public static bool Missing<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable, SearchOptions? options = null)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Missing(options);
public static ValueProvider<string, TOwner> Content<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Content;
public static UIComponentVerificationProvider<Control<TOwner>, TOwner> Should<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().Should;
public static UIComponentVerificationProvider<Control<TOwner>, TOwner> ExpectTo<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().ExpectTo;
public static UIComponentVerificationProvider<Control<TOwner>, TOwner> WaitTo<TNavigateTo, TOwner>(this ClickableDelegate<TNavigateTo, TOwner> clickable)
where TNavigateTo : PageObject<TNavigateTo>
where TOwner : PageObject<TOwner>
=>
clickable.GetControl().WaitTo;
}
| ClickableDelegate2Extensions |
csharp | unoplatform__uno | src/Uno.UWP/Generated/3.0.0.0/Windows.Devices.Perception/PerceptionColorFrameArrivedEventArgs.cs | {
"start": 360,
"end": 1943
} | public partial class ____
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
internal PerceptionColorFrameArrivedEventArgs()
{
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::System.TimeSpan RelativeTime
{
get
{
throw new global::System.NotImplementedException("The member TimeSpan PerceptionColorFrameArrivedEventArgs.RelativeTime is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=TimeSpan%20PerceptionColorFrameArrivedEventArgs.RelativeTime");
}
}
#endif
// Forced skipping of method Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs.RelativeTime.get
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::Windows.Devices.Perception.PerceptionColorFrame TryOpenFrame()
{
throw new global::System.NotImplementedException("The member PerceptionColorFrame PerceptionColorFrameArrivedEventArgs.TryOpenFrame() is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=PerceptionColorFrame%20PerceptionColorFrameArrivedEventArgs.TryOpenFrame%28%29");
}
#endif
}
}
| PerceptionColorFrameArrivedEventArgs |
csharp | MapsterMapper__Mapster | src/Mapster.Tests/WhenFlattening.cs | {
"start": 472,
"end": 542
} | public class ____
{
public B BClass { get; set; }
}
| C |
csharp | npgsql__efcore.pg | test/EFCore.PG.FunctionalTests/NpgsqlValueGenerationScenariosTest.cs | {
"start": 1783,
"end": 3418
} | public class ____(string databaseName) : ContextBase(databaseName)
{
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.UseHiLo();
}
}
[Fact]
public async Task Insert_with_default_value_from_sequence()
{
await using var testStore = await NpgsqlTestStore.CreateInitializedAsync(DatabaseName);
using (var context = new BlogContextDefaultValue(testStore.Name))
{
context.Database.EnsureCreated();
context.AddRange(
new Blog { Name = "One Unicorn" },
new Blog { Name = "Two Unicorns" });
context.SaveChanges();
}
using (var context = new BlogContextDefaultValue(testStore.Name))
{
var blogs = context.Blogs.OrderBy(e => e.Id).ToList();
Assert.Equal(0, blogs[0].Id);
Assert.Equal(1, blogs[1].Id);
}
using (var context = new BlogContextDefaultValueNoMigrations(testStore.Name))
{
context.AddRange(
new Blog { Name = "One Unicorn" },
new Blog { Name = "Two Unicorns" });
context.SaveChanges();
}
using (var context = new BlogContextDefaultValueNoMigrations(testStore.Name))
{
var blogs = context.Blogs.OrderBy(e => e.Id).ToList();
Assert.Equal(0, blogs[0].Id);
Assert.Equal(1, blogs[1].Id);
Assert.Equal(2, blogs[2].Id);
Assert.Equal(3, blogs[3].Id);
}
}
| BlogContextHiLo |
csharp | FoundatioFx__Foundatio | src/Foundatio/Utility/SharedOptions.cs | {
"start": 226,
"end": 1311
} | public class ____
{
private IResiliencePolicyProvider _policyProvider;
private TimeProvider _timeProvider;
private ISerializer _serializer;
private ILoggerFactory _loggerFactory;
internal bool HasResiliencePolicyProvider => _policyProvider != null;
public IResiliencePolicyProvider ResiliencePolicyProvider
{
get => _policyProvider ?? DefaultResiliencePolicyProvider.Instance;
set => _policyProvider = value;
}
internal bool HasTimeProvider => _timeProvider != null;
public TimeProvider TimeProvider
{
get => _timeProvider ?? TimeProvider.System;
set => _timeProvider = value;
}
internal bool HasSerializer => _serializer != null;
public ISerializer Serializer
{
get => _serializer ?? DefaultSerializer.Instance;
set => _serializer = value;
}
internal bool HasLoggerFactory => _loggerFactory != null;
public ILoggerFactory LoggerFactory
{
get => _loggerFactory ?? NullLoggerFactory.Instance;
set => _loggerFactory = value;
}
}
| SharedOptions |
csharp | Antaris__RazorEngine | src/source/RazorEngine.Core/Legacy/Templating/TemplateService.cs | {
"start": 608,
"end": 22377
} | public class ____ : CrossAppDomainObject, ITemplateService
{
#region Fields
private readonly RazorEngineService _service;
private bool disposed;
#endregion
#region Constructor
/// <summary>
/// Initialises a new instance of <see cref="TemplateService"/>
/// </summary>
/// <param name="config">The template service configuration.</param>
public TemplateService(ITemplateServiceConfiguration config)
{
Contract.Requires(config != null);
_service = new RazorEngineService(config);
}
internal TemplateService(RazorEngineService service)
{
Contract.Requires(service != null);
_service = service;
}
/// <summary>
/// Initialises a new instance of <see cref="TemplateService"/>.
/// </summary>
public TemplateService()
: this(new TemplateServiceConfiguration() { CompilerServiceFactory = new DefaultCompilerServiceFactory() }) { }
/// <summary>
/// Initialises a new instance of <see cref="TemplateService"/>
/// </summary>
/// <param name="language">The code language.</param>
/// <param name="encoding">the encoding.</param>
internal TemplateService(Language language, Encoding encoding)
: this(new TemplateServiceConfiguration() { Language = language, EncodedStringFactory = GetEncodedStringFactory(encoding), CompilerServiceFactory = new DefaultCompilerServiceFactory() }) { }
#endregion
#region Properties
/// <summary>
/// Gets the template service configuration.
/// </summary>
public ITemplateServiceConfiguration Configuration { get { return _service.Configuration; } }
/// <summary>
/// Gets the encoded string factory.
/// </summary>
public IEncodedStringFactory EncodedStringFactory { get { return _service.Configuration.EncodedStringFactory; } }
#endregion
#region Methods
private ITemplateKey GetKeyAndAdd(string template, string name = null)
{
if (name == null)
{
name = "dynamic_" + Guid.NewGuid().ToString();
}
var key = _service.GetKey(name);
var source = new LoadedTemplateSource(template);
_service.Configuration.TemplateManager.AddDynamic(key, source);
return key;
}
private Type CheckModelType(Type modelType)
{
if (modelType == null)
{
return null;
}
if (CompilerServicesUtility.IsAnonymousTypeRecursive(modelType))
{
//throw new ArgumentException("Cannot use anonymous type as model type.");
modelType = null;
}
if (modelType != null && CompilerServicesUtility.IsDynamicType(modelType))
{
modelType = null;
}
return modelType;
}
private Tuple<object, Type> CheckModel(object model)
{
if (model == null)
{
return Tuple.Create((object)null, (Type)null);
}
Type modelType = (model == null) ? typeof(object) : model.GetType();
bool isAnon = CompilerServicesUtility.IsAnonymousTypeRecursive(modelType);
if (isAnon ||
CompilerServicesUtility.IsDynamicType(modelType))
{
modelType = null;
if (isAnon || Configuration.AllowMissingPropertiesOnDynamic)
{
model = RazorDynamicObject.Create(model, Configuration.AllowMissingPropertiesOnDynamic);
}
}
return Tuple.Create(model, modelType);
}
/// <summary>
/// Creates a new <see cref="InstanceContext"/> for creating template instances.
/// </summary>
/// <param name="templateType">The template type.</param>
/// <returns>An instance of <see cref="InstanceContext"/>.</returns>
[Pure]
protected virtual InstanceContext CreateInstanceContext(Type templateType)
{
return _service.Core.CreateInstanceContext(templateType);
}
/// <summary>
/// Adds a namespace that will be imported into the template.
/// </summary>
/// <param name="ns">The namespace to be imported.</param>
public void AddNamespace(string ns)
{
Configuration.Namespaces.Add(ns);
}
/// <summary>
/// Compiles the specified template.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="modelType">The model type.</param>
/// <param name="name">The name of the template.</param>
public void Compile(string razorTemplate, Type modelType, string name)
{
Contract.Requires(razorTemplate != null);
Contract.Requires(name != null);
_service.Compile(GetKeyAndAdd(razorTemplate, name), CheckModelType(modelType));
}
/// <summary>
/// Creates a ExecuteContext
/// </summary>
/// <param name="viewBag"></param>
/// <returns></returns>
public ExecuteContext CreateExecuteContext (DynamicViewBag viewBag = null)
{
if (viewBag != null)
throw new NotSupportedException("This kind of usage is no longer supported, please switch to the non-obsolete API.");
return _service.Core.CreateExecuteContext();
}
/// <summary>
/// Creates an instance of <see cref="ITemplate"/> from the specified string template.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="staticType">type used in the compilation.</param>
/// <param name="model">The model instance.</param>
/// <returns>An instance of <see cref="ITemplate"/>.</returns>
[Pure]
public virtual ITemplate CreateTemplate(string razorTemplate, Type staticType, object model)
{
var key = GetKeyAndAdd(razorTemplate);
ICompiledTemplate compiledTemplate;
var check = CheckModel(model);
Type modelType = check.Item2;
model = check.Item1;
if (staticType == null) {
compiledTemplate = _service.CompileAndCacheInternal(key, modelType);
}
else
{
var source = _service.Core.Resolve(key);
compiledTemplate = new CompiledTemplate(new CompilationData(null, null), key, source, staticType, modelType);
}
return _service.Core.CreateTemplate(compiledTemplate, model, null);
}
/// <summary>
/// Creates a set of templates from the specified string templates and models.
/// </summary>
/// <param name="razorTemplates">The set of templates to create <see cref="ITemplate"/> instances for.</param>
/// <param name="models">The set of models used to assign to templates.</param>
/// <param name="parallel">Flag to determine whether to create templates in parallel.</param>
/// <param name="types">the mode types.</param>
/// <returns>The enumerable set of template instances.</returns>
[Pure]
public virtual IEnumerable<ITemplate> CreateTemplates(IEnumerable<string> razorTemplates, IEnumerable<Type> types, IEnumerable<object> models, bool parallel = false)
{
Contract.Requires(razorTemplates != null);
var l = razorTemplates.ToList();
var typeList = (types ?? Enumerable.Repeat<Type>(null, l.Count)).ToList();
var modelList = (models ?? Enumerable.Repeat<object>(null, l.Count)).ToList();
if (parallel)
return GetParallelQueryPlan<string>()
.CreateQuery(razorTemplates)
.Select((t, i) => CreateTemplate(t, typeList[i], modelList[i]));
return razorTemplates.Select((t, i) => CreateTemplate(t, typeList[i], modelList[i]));
}
/// <summary>
/// Creates a <see cref="Type"/> that can be used to instantiate an instance of a template.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="modelType">The model type.</param>
/// <returns>An instance of <see cref="Type"/>.</returns>
[Pure]
public virtual Type CreateTemplateType(string razorTemplate, Type modelType)
{
var result = _service.Core.CreateTemplateType(new LoadedTemplateSource(razorTemplate), CheckModelType(modelType));
result.Item2.DeleteAll();
return result.Item1;
}
/// <summary>
/// Creates a set of template types from the specfied string templates.
/// </summary>
/// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param>
/// <param name="types">The modeltypes</param>
/// <param name="parallel">Flag to determine whether to create template types in parallel.</param>
/// <returns>The set of <see cref="Type"/> instances.</returns>
[Pure]
public virtual IEnumerable<Type> CreateTemplateTypes(IEnumerable<string> razorTemplates, IEnumerable<Type> types, bool parallel = false)
{
Contract.Requires(razorTemplates != null);
var typeList = types.ToList();
if (parallel)
return GetParallelQueryPlan<string>()
.CreateQuery(razorTemplates)
.Select((t, i) => CreateTemplateType(t, typeList[i]));
return razorTemplates.Select((t, i) => CreateTemplateType(t, typeList[i]));
}
/// <summary>
/// Releases managed resources used by this instance.
/// </summary>
/// <param name="disposing">Are we explicitly disposing of this instance?</param>
protected override void Dispose(bool disposing)
{
if (!disposed && disposing)
{
_service.Dispose();
disposed = true;
}
base.Dispose(disposing);
}
/// <summary>
/// Gets an instance of a <see cref="IEncodedStringFactory"/> for a known encoding.
/// </summary>
/// <param name="encoding">The encoding to get a factory for.</param>
/// <returns>An instance of <see cref="IEncodedStringFactory"/></returns>
internal static IEncodedStringFactory GetEncodedStringFactory(Encoding encoding)
{
switch (encoding)
{
case Encoding.Html:
return new HtmlEncodedStringFactory();
case Encoding.Raw:
return new RawStringFactory();
default:
throw new ArgumentException("Unsupported encoding: " + encoding);
}
}
/// <summary>
/// Gets a parellel query plan used to configure a parallel query.
/// </summary>
/// <typeparam name="T">The query item type.</typeparam>
/// <returns>An instance of <see cref="IParallelQueryPlan{T}"/>.</returns>
protected virtual IParallelQueryPlan<T> GetParallelQueryPlan<T>()
{
return new DefaultParallelQueryPlan<T>();
}
/// <summary>
/// Gets an instance of the template using the cached compiled type, or compiles the template type
/// if it does not exist in the cache.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="model">The model instance.</param>
/// <param name="name">The name of the template type in the cache.</param>
/// <returns>An instance of <see cref="ITemplate{T}"/>.</returns>
public virtual ITemplate GetTemplate(string razorTemplate, object model, string name)
{
if (razorTemplate == null)
throw new ArgumentNullException("razorTemplate");
var key = GetKeyAndAdd(razorTemplate, name);
var check = CheckModel(model);
Type modelType = check.Item2;
model = check.Item1;
return _service.GetTemplate(key, modelType, model, null);
}
/// <summary>
/// Gets an instance of the template using the cached compiled type, or compiles the template type
/// if it does not exist in the cache.
/// </summary>
/// <typeparam name="T">The model type.</typeparam>
/// <param name="razorTemplate">The string template.</param>
/// <param name="model">The model instance.</param>
/// <param name="name">The name of the template type in the cache.</param>
/// <returns>An instance of <see cref="ITemplate{T}"/>.</returns>
public virtual ITemplate GetTemplate<T>(string razorTemplate, object model, string name)
{
if (razorTemplate == null)
throw new ArgumentNullException("razorTemplate");
var key = GetKeyAndAdd(razorTemplate, name);
var check = CheckModel(model);
model = check.Item1;
return _service.GetTemplate(key, typeof(T), model, null);
}
/// <summary>
/// Gets the set of template instances for the specified string templates. Cached templates will be considered
/// and if they do not exist, new types will be created and instantiated.
/// </summary>
/// <param name="razorTemplates">The set of templates to create.</param>
/// <param name="models">The set of models.</param>
/// <param name="names">The set of cache names.</param>
/// <param name="parallel">Flag to determine whether to get the templates in parallel.</param>
/// <returns>The set of <see cref="ITemplate"/> instances.</returns>
public virtual IEnumerable<ITemplate> GetTemplates(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<string> names, bool parallel = false)
{
Contract.Requires(razorTemplates != null);
var l = razorTemplates.ToList();
var modelList = (models ?? Enumerable.Repeat<object>(null, l.Count)).ToList();
var nameList = (names ?? Enumerable.Repeat<string>(null, l.Count)).ToList();
if (parallel)
return GetParallelQueryPlan<string>()
.CreateQuery(l)
.Select((t, i) => GetTemplate(t, modelList[i], nameList[i]));
return l.Select((t, i) => GetTemplate(t, modelList[i], nameList[i]));
}
/// <summary>
/// Parses and returns the result of the specified string template.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="model">The model instance.</param>
/// <param name="viewBag">The viewbag.</param>
/// <param name="cacheName">The cacheName.</param>
/// <returns>The string result of the template.</returns>
[Pure]
public virtual string Parse(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName)
{
ITemplate instance;
if (cacheName == null)
instance = CreateTemplate(razorTemplate, null, model);
else
instance = GetTemplate(razorTemplate, model, cacheName);
return Run(instance, viewBag);
}
/// <summary>
/// Parses and returns the result of the specified string template.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="model">The model instance or NULL if no model exists.</param>
/// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param>
/// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param>
/// <returns>The string result of the template.</returns>
[Pure]
public virtual string Parse<T>(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName)
{
using(var writer = new System.IO.StringWriter())
{
var key = GetKeyAndAdd(razorTemplate, cacheName);
var check = CheckModel(model);
model = check.Item1;
_service.RunCompile(GetKeyAndAdd(razorTemplate, cacheName), writer, typeof(T), model, viewBag);
return writer.ToString();
}
}
/// <summary>
/// Parses the specified set of templates.
/// </summary>
/// <param name="razorTemplates">The set of string templates to parse.</param>
/// <param name="models">The set of models.</param>
/// <param name="viewBags">The viewbags</param>
/// <param name="names">The set of cache names.</param>
/// <param name="parallel">Flag to determine whether parsing in parallel.</param>
/// <returns>The set of parsed template results.</returns>
public virtual IEnumerable<string> ParseMany(IEnumerable<string> razorTemplates, IEnumerable<object> models, IEnumerable<DynamicViewBag> viewBags, IEnumerable<string> names, bool parallel)
{
Contract.Requires(razorTemplates != null);
var templates = razorTemplates.ToList();
var modelList = (models ?? Enumerable.Repeat<object>(null, templates.Count)).ToList();
var bags = (viewBags ?? Enumerable.Repeat<DynamicViewBag>(null, templates.Count)).ToList();
var nameList = (names ?? Enumerable.Repeat<string>(null, templates.Count)).ToList();
if (parallel)
return GetParallelQueryPlan<string>()
.CreateQuery(templates)
.Select((t, i) => Parse(t, modelList[i], bags[i], nameList[i]))
.ToArray();
return templates.Select((t, i) => Parse(t, modelList[i], bags[i], nameList[i])).ToArray();
}
/// <summary>
/// Returns whether or not a template by the specified name has been created already.
/// </summary>
/// <param name="name">The name of the template.</param>
/// <returns>Whether or not the template has been created.</returns>
public bool HasTemplate(string name)
{
throw new InvalidOperationException("This member is no longer supported!");
}
/// <summary>
/// NOT SUPPORTED.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool RemoveTemplate(string name)
{
throw new InvalidOperationException("This member is no longer supported!");
}
/// <summary>
/// Resolves the template with the specified name.
/// </summary>
/// <param name="name">The name of the template.</param>
/// <param name="model">The model for the template.</param>
/// <returns>The resolved template.</returns>
public ITemplate Resolve(string name, object model)
{
var check = CheckModel(model);
var modelType = check.Item2;
model = check.Item1;
return _service.GetTemplate(
_service.GetKey(name), modelType, model, null);
}
/// <summary>
/// Runs the template with the specified name.
/// </summary>
/// <param name="name">The name of the template.</param>
/// <param name="model">The model.</param>
/// <param name="viewBag">The viewBag.</param>
/// <returns>The string result of the template.</returns>
public string Run(string name, object model, DynamicViewBag viewBag)
{
if (string.IsNullOrWhiteSpace(name))
throw new ArgumentException("'name' is a required parameter.");
using(var writer = new System.IO.StringWriter())
{
var check = CheckModel(model);
var modelType = check.Item2;
model = check.Item1;
_service.Run(_service.GetKey(name), writer, modelType, model, viewBag);
return writer.ToString();
}
}
/// <summary>
/// Runs the template with the specified name.
/// </summary>
/// <param name="template">The template.</param>
/// <param name="viewBag">The viewbag.</param>
/// <returns>The string result of the template.</returns>
public string Run(ITemplate template, DynamicViewBag viewBag)
{
if (template == null)
throw new ArgumentNullException("template");
using (var writer = new System.IO.StringWriter())
{
template.SetData(null, viewBag);
#if RAZOR4
try
{
template.Run(CreateExecuteContext(), writer).Wait();
}
catch (AggregateException ex)
{
ExceptionDispatchInfo.Capture(ex.Flatten().InnerExceptions.First()).Throw();
}
#else
template.Run(CreateExecuteContext(), writer);
#endif
return writer.ToString();
}
}
#endregion
}
} | TemplateService |
csharp | aspnetboilerplate__aspnetboilerplate | test/Abp.Tests/Json/EntityDtoSerialization_Tests.cs | {
"start": 658,
"end": 721
} | public class ____ : EntityDto
{
}
}
}
| MyClass2 |
csharp | abpframework__abp | framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Json/JsonResultController_Tests.cs | {
"start": 171,
"end": 732
} | public class ____ : AspNetCoreMvcTestBase
{
protected override void ConfigureServices(IServiceCollection services)
{
services.Configure<AbpJsonOptions>(options =>
{
options.OutputDateTimeFormat = "yyyy*MM*dd";
});
base.ConfigureServices(services);
}
[Fact]
public async Task DateFormatString_Test()
{
var time = await GetResponseAsStringAsync(
"/api/json-result-test/json-result-action"
);
time.ShouldContain("2019*01*01");
}
}
| JsonResultController_Tests |
csharp | AutoMapper__AutoMapper | src/IntegrationTests/IncludeMembers.cs | {
"start": 16684,
"end": 18873
} | public class ____ : DropCreateDatabaseAlways<Context>
{
protected override void Seed(Context context)
{
var source = new Source
{
Name = "name",
InnerSourceWrappers = { new InnerSourceWrapper { InnerSource = new InnerSource { InnerSourceDetailsWrapper = { new InnerSourceDetailsWrapper { InnerSourceDetails = new InnerSourceDetails { Description = "description", Publisher = "publisher" } } } } }
},
OtherInnerSources = { new OtherInnerSource { OtherInnerSourceDetails = { new OtherInnerSourceDetails { Title = "title", Author = "author" } } } }
};
context.Sources.Add(source);
base.Seed(context);
}
}
protected override MapperConfiguration CreateConfiguration() => new(cfg =>
{
cfg.CreateProjection<Source, Destination>().IncludeMembers(s => s.InnerSourceWrappers.Select(s => s.InnerSource).FirstOrDefault(), s => s.OtherInnerSources.Select(s=>s).FirstOrDefault());
cfg.CreateProjection<InnerSource, Destination>(MemberList.None).ForMember(d => d.Details, o => o.MapFrom(s => s.InnerSourceDetailsWrapper.Select(s => s.InnerSourceDetails).FirstOrDefault()));
cfg.CreateProjection<OtherInnerSource, Destination>(MemberList.None).ForMember(d => d.OtherDetails, o => o.MapFrom(s => s.OtherInnerSourceDetails.Select(s => s).FirstOrDefault()));
cfg.CreateProjection<InnerSourceDetails, DestinationDetails>();
cfg.CreateProjection<OtherInnerSourceDetails, OtherDestinationDetails>();
});
[Fact]
public void Should_flatten()
{
using (var context = Fixture.CreateContext())
{
var projectTo = ProjectTo<Destination>(context.Sources);
FirstOrDefaultCounter.Assert(projectTo, 4);
var result = projectTo.Single();
result.Name.ShouldBe("name");
result.Details.Description.ShouldBe("description");
result.Details.Publisher.ShouldBe("publisher");
result.OtherDetails.Title.ShouldBe("title");
result.OtherDetails.Author.ShouldBe("author");
}
}
}
| DatabaseInitializer |
csharp | unoplatform__uno | src/Uno.UWP/Generated/3.0.0.0/Windows.Devices.PointOfService.Provider/BarcodeScannerStartSoftwareTriggerRequestEventArgs.cs | {
"start": 314,
"end": 2073
} | public partial class ____
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
internal BarcodeScannerStartSoftwareTriggerRequestEventArgs()
{
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest Request
{
get
{
throw new global::System.NotImplementedException("The member BarcodeScannerStartSoftwareTriggerRequest BarcodeScannerStartSoftwareTriggerRequestEventArgs.Request is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=BarcodeScannerStartSoftwareTriggerRequest%20BarcodeScannerStartSoftwareTriggerRequestEventArgs.Request");
}
}
#endif
// Forced skipping of method Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs.Request.get
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::Windows.Foundation.Deferral GetDeferral()
{
throw new global::System.NotImplementedException("The member Deferral BarcodeScannerStartSoftwareTriggerRequestEventArgs.GetDeferral() is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=Deferral%20BarcodeScannerStartSoftwareTriggerRequestEventArgs.GetDeferral%28%29");
}
#endif
}
}
| BarcodeScannerStartSoftwareTriggerRequestEventArgs |
csharp | FastEndpoints__FastEndpoints | Src/Messaging/Messaging.Remote.Core/Client/Events/EventSubscriber.cs | {
"start": 9113,
"end": 10511
} | record ____ needed.
await Task.Delay(5000);
return;
}
var markCompletionErrorCount = 0;
while (!_isInMemProvider)
{
try
{
record.IsComplete = true;
await storage.MarkEventAsCompleteAsync(record, opts.CancellationToken);
markCompletionErrorCount = 0;
break;
}
catch (Exception ex)
{
errorReceiver?.OnMarkEventAsCompleteError<TEvent>(record, markCompletionErrorCount++, ex, opts.CancellationToken);
logger.StorageMarkAsCompleteError(subscriberID, typeof(TEvent).FullName!, ex.Message);
if (opts.CancellationToken.IsCancellationRequested)
break;
await Task.Delay(5000);
}
}
}
}
else
{
//wait until either the semaphore is released or a minute has elapsed
await Task.WhenAny(sem.WaitAsync(opts.CancellationToken), Task.Delay(10000));
}
}
}
} | if |
csharp | AvaloniaUI__Avalonia | src/Avalonia.Controls/Presenters/ContentPresenter.cs | {
"start": 607,
"end": 25788
} | public class ____ : Control
{
/// <summary>
/// Defines the <see cref="Background"/> property.
/// </summary>
public static readonly StyledProperty<IBrush?> BackgroundProperty =
Border.BackgroundProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="BackgroundSizing"/> property.
/// </summary>
public static readonly StyledProperty<BackgroundSizing> BackgroundSizingProperty =
Border.BackgroundSizingProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="BorderBrush"/> property.
/// </summary>
public static readonly StyledProperty<IBrush?> BorderBrushProperty =
Border.BorderBrushProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="BorderThickness"/> property.
/// </summary>
public static readonly StyledProperty<Thickness> BorderThicknessProperty =
Border.BorderThicknessProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="CornerRadius"/> property.
/// </summary>
public static readonly StyledProperty<CornerRadius> CornerRadiusProperty =
Border.CornerRadiusProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="BoxShadow"/> property.
/// </summary>
public static readonly StyledProperty<BoxShadows> BoxShadowProperty =
Border.BoxShadowProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="Foreground"/> property.
/// </summary>
public static readonly StyledProperty<IBrush?> ForegroundProperty =
TextElement.ForegroundProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="FontFamily"/> property.
/// </summary>
public static readonly StyledProperty<FontFamily> FontFamilyProperty =
TextElement.FontFamilyProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="FontSize"/> property.
/// </summary>
public static readonly StyledProperty<double> FontSizeProperty =
TextElement.FontSizeProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="FontStyle"/> property.
/// </summary>
public static readonly StyledProperty<FontStyle> FontStyleProperty =
TextElement.FontStyleProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="FontWeight"/> property.
/// </summary>
public static readonly StyledProperty<FontWeight> FontWeightProperty =
TextElement.FontWeightProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="FontStretch"/> property.
/// </summary>
public static readonly StyledProperty<FontStretch> FontStretchProperty =
TextElement.FontStretchProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="TextAlignment"/> property
/// </summary>
public static readonly StyledProperty<TextAlignment> TextAlignmentProperty =
TextBlock.TextAlignmentProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="TextWrapping"/> property
/// </summary>
public static readonly StyledProperty<TextWrapping> TextWrappingProperty =
TextBlock.TextWrappingProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="TextTrimming"/> property
/// </summary>
public static readonly StyledProperty<TextTrimming> TextTrimmingProperty =
TextBlock.TextTrimmingProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="LineHeight"/> property
/// </summary>
public static readonly StyledProperty<double> LineHeightProperty =
TextBlock.LineHeightProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="MaxLines"/> property
/// </summary>
public static readonly StyledProperty<int> MaxLinesProperty =
TextBlock.MaxLinesProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="Child"/> property.
/// </summary>
public static readonly DirectProperty<ContentPresenter, Control?> ChildProperty =
AvaloniaProperty.RegisterDirect<ContentPresenter, Control?>(
nameof(Child),
o => o.Child);
/// <summary>
/// Defines the <see cref="Content"/> property.
/// </summary>
public static readonly StyledProperty<object?> ContentProperty =
ContentControl.ContentProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="ContentTemplate"/> property.
/// </summary>
public static readonly StyledProperty<IDataTemplate?> ContentTemplateProperty =
ContentControl.ContentTemplateProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="HorizontalContentAlignment"/> property.
/// </summary>
public static readonly StyledProperty<HorizontalAlignment> HorizontalContentAlignmentProperty =
ContentControl.HorizontalContentAlignmentProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="VerticalContentAlignment"/> property.
/// </summary>
public static readonly StyledProperty<VerticalAlignment> VerticalContentAlignmentProperty =
ContentControl.VerticalContentAlignmentProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="Padding"/> property.
/// </summary>
public static readonly StyledProperty<Thickness> PaddingProperty =
Decorator.PaddingProperty.AddOwner<ContentPresenter>();
/// <summary>
/// Defines the <see cref="RecognizesAccessKey"/> property
/// </summary>
public static readonly StyledProperty<bool> RecognizesAccessKeyProperty =
AvaloniaProperty.Register<ContentPresenter, bool>(nameof(RecognizesAccessKey));
private Control? _child;
private bool _createdChild;
private IRecyclingDataTemplate? _recyclingDataTemplate;
private readonly BorderRenderHelper _borderRenderer = new BorderRenderHelper();
/// <summary>
/// Initializes static members of the <see cref="ContentPresenter"/> class.
/// </summary>
static ContentPresenter()
{
AffectsRender<ContentPresenter>(
BackgroundProperty,
BackgroundSizingProperty,
BorderBrushProperty,
BorderThicknessProperty,
BoxShadowProperty,
CornerRadiusProperty);
AffectsArrange<ContentPresenter>(HorizontalContentAlignmentProperty, VerticalContentAlignmentProperty);
AffectsMeasure<ContentPresenter>(BorderThicknessProperty, PaddingProperty);
}
public ContentPresenter()
{
UpdatePseudoClasses();
}
/// <inheritdoc cref="Border.Background"/>
public IBrush? Background
{
get => GetValue(BackgroundProperty);
set => SetValue(BackgroundProperty, value);
}
/// <inheritdoc cref="Border.BackgroundSizing"/>
public BackgroundSizing BackgroundSizing
{
get => GetValue(BackgroundSizingProperty);
set => SetValue(BackgroundSizingProperty, value);
}
/// <inheritdoc cref="Border.BorderBrush"/>
public IBrush? BorderBrush
{
get => GetValue(BorderBrushProperty);
set => SetValue(BorderBrushProperty, value);
}
/// <inheritdoc cref="Border.BorderThickness"/>
public Thickness BorderThickness
{
get => GetValue(BorderThicknessProperty);
set => SetValue(BorderThicknessProperty, value);
}
/// <inheritdoc cref="Border.CornerRadius"/>
public CornerRadius CornerRadius
{
get => GetValue(CornerRadiusProperty);
set => SetValue(CornerRadiusProperty, value);
}
/// <inheritdoc cref="Border.BoxShadow"/>
public BoxShadows BoxShadow
{
get => GetValue(BoxShadowProperty);
set => SetValue(BoxShadowProperty, value);
}
/// <summary>
/// Gets or sets a brush used to paint the text.
/// </summary>
public IBrush? Foreground
{
get => GetValue(ForegroundProperty);
set => SetValue(ForegroundProperty, value);
}
/// <summary>
/// Gets or sets the font family.
/// </summary>
public FontFamily FontFamily
{
get => GetValue(FontFamilyProperty);
set => SetValue(FontFamilyProperty, value);
}
/// <summary>
/// Gets or sets the font size.
/// </summary>
public double FontSize
{
get => GetValue(FontSizeProperty);
set => SetValue(FontSizeProperty, value);
}
/// <summary>
/// Gets or sets the font style.
/// </summary>
public FontStyle FontStyle
{
get => GetValue(FontStyleProperty);
set => SetValue(FontStyleProperty, value);
}
/// <summary>
/// Gets or sets the font weight.
/// </summary>
public FontWeight FontWeight
{
get => GetValue(FontWeightProperty);
set => SetValue(FontWeightProperty, value);
}
/// <summary>
/// Gets or sets the font stretch.
/// </summary>
public FontStretch FontStretch
{
get => GetValue(FontStretchProperty);
set => SetValue(FontStretchProperty, value);
}
/// <summary>
/// Gets or sets the text alignment
/// </summary>
public TextAlignment TextAlignment
{
get => GetValue(TextAlignmentProperty);
set => SetValue(TextAlignmentProperty, value);
}
/// <summary>
/// Gets or sets the text wrapping
/// </summary>
public TextWrapping TextWrapping
{
get => GetValue(TextWrappingProperty);
set => SetValue(TextWrappingProperty, value);
}
/// <summary>
/// Gets or sets the text trimming
/// </summary>
public TextTrimming TextTrimming
{
get => GetValue(TextTrimmingProperty);
set => SetValue(TextTrimmingProperty, value);
}
/// <summary>
/// Gets or sets the line height
/// </summary>
public double LineHeight
{
get => GetValue(LineHeightProperty);
set => SetValue(LineHeightProperty, value);
}
/// <summary>
/// Gets or sets the max lines
/// </summary>
public int MaxLines
{
get => GetValue(MaxLinesProperty);
set => SetValue(MaxLinesProperty, value);
}
/// <summary>
/// Gets the control displayed by the presenter.
/// </summary>
public Control? Child
{
get => _child;
private set => SetAndRaise(ChildProperty, ref _child, value);
}
/// <summary>
/// Gets or sets the content to be displayed by the presenter.
/// </summary>
[DependsOn(nameof(ContentTemplate))]
public object? Content
{
get => GetValue(ContentProperty);
set => SetValue(ContentProperty, value);
}
/// <summary>
/// Gets or sets the data template used to display the content of the control.
/// </summary>
public IDataTemplate? ContentTemplate
{
get => GetValue(ContentTemplateProperty);
set => SetValue(ContentTemplateProperty, value);
}
/// <summary>
/// Gets or sets the horizontal alignment of the content within the border the control.
/// </summary>
public HorizontalAlignment HorizontalContentAlignment
{
get => GetValue(HorizontalContentAlignmentProperty);
set => SetValue(HorizontalContentAlignmentProperty, value);
}
/// <summary>
/// Gets or sets the vertical alignment of the content within the border of the control.
/// </summary>
public VerticalAlignment VerticalContentAlignment
{
get => GetValue(VerticalContentAlignmentProperty);
set => SetValue(VerticalContentAlignmentProperty, value);
}
/// <summary>
/// Gets or sets the space between the border and the <see cref="Child"/> control.
/// </summary>
public Thickness Padding
{
get => GetValue(PaddingProperty);
set => SetValue(PaddingProperty, value);
}
/// <summary>
/// Determine if <see cref="ContentPresenter"/> should use <see cref="AccessText"/> in its style
/// </summary>
public bool RecognizesAccessKey
{
get => GetValue(RecognizesAccessKeyProperty);
set => SetValue(RecognizesAccessKeyProperty, value);
}
/// <summary>
/// Gets the host content control.
/// </summary>
internal IContentPresenterHost? Host { get; private set; }
/// <inheritdoc/>
public sealed override void ApplyTemplate()
{
if (!_createdChild && ((ILogical)this).IsAttachedToLogicalTree)
{
UpdateChild();
}
}
protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
{
base.OnPropertyChanged(change);
switch (change.Property.Name)
{
case nameof(Content):
case nameof(ContentTemplate):
ContentChanged(change);
break;
case nameof(TemplatedParent):
TemplatedParentChanged(change);
break;
case nameof(UseLayoutRounding):
case nameof(BorderThickness):
_layoutThickness = null;
break;
}
}
/// <summary>
/// Updates the <see cref="Child"/> control based on the control's <see cref="Content"/>.
/// </summary>
/// <remarks>
/// Usually the <see cref="Child"/> control is created automatically when
/// <see cref="ApplyTemplate"/> is called; however for this to happen, the control needs to
/// be attached to a logical tree (if the control is not attached to the logical tree, it
/// is reasonable to expect that the DataTemplates needed for the child are not yet
/// available). This method forces the <see cref="Child"/> control's creation at any point,
/// and is particularly useful in unit tests.
/// </remarks>
public void UpdateChild()
{
var content = Content;
UpdateChild(content);
}
private void UpdateChild(object? content)
{
var contentTemplate = ContentTemplate;
var oldChild = Child;
var newChild = CreateChild(content, oldChild, contentTemplate);
var logicalChildren = GetEffectiveLogicalChildren();
// Remove the old child if we're not recycling it.
if (newChild != oldChild)
{
if (oldChild != null)
{
VisualChildren.Remove(oldChild);
logicalChildren.Remove(oldChild);
((ISetInheritanceParent)oldChild).SetParent(oldChild.Parent);
}
}
// Set the DataContext if the data isn't a control.
if (contentTemplate is { } || !(content is Control))
{
DataContext = content;
}
else
{
ClearValue(DataContextProperty);
}
// Update the Child.
if (newChild == null)
{
Child = null;
}
else if (newChild != oldChild)
{
((ISetInheritanceParent)newChild).SetParent(this);
Child = newChild;
if (!logicalChildren.Contains(newChild))
{
logicalChildren.Add(newChild);
}
VisualChildren.Add(newChild);
}
_createdChild = true;
}
private IAvaloniaList<ILogical> GetEffectiveLogicalChildren()
=> Host?.LogicalChildren ?? LogicalChildren;
/// <inheritdoc/>
protected override void OnAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e)
{
base.OnAttachedToLogicalTree(e);
_recyclingDataTemplate = null;
_createdChild = false;
InvalidateMeasure();
}
private Thickness? _layoutThickness;
private double _scale;
private Thickness LayoutThickness
{
get
{
VerifyScale();
if (_layoutThickness == null)
{
var borderThickness = BorderThickness;
if (UseLayoutRounding)
borderThickness = LayoutHelper.RoundLayoutThickness(borderThickness, _scale);
_layoutThickness = borderThickness;
}
return _layoutThickness.Value;
}
}
private void VerifyScale()
{
var currentScale = LayoutHelper.GetLayoutScale(this);
if (MathUtilities.AreClose(currentScale, _scale))
return;
_scale = currentScale;
_layoutThickness = null;
}
/// <inheritdoc/>
public sealed override void Render(DrawingContext context)
{
_borderRenderer.Render(
context,
Bounds.Size,
LayoutThickness,
CornerRadius,
BackgroundSizing,
Background,
BorderBrush,
BoxShadow);
}
private Control? CreateChild(object? content, Control? oldChild, IDataTemplate? template)
{
var newChild = content as Control;
// We want to allow creating Child from the Template, if Content is null.
// But it's important to not use DataTemplates, otherwise we will break content presenters in many places,
// otherwise it will blow up every ContentPresenter without Content set.
if ((newChild == null
&& (content != null || template != null)) || (newChild is { } && template is { }))
{
var dataTemplate = this.FindDataTemplate(content, template) ??
(
RecognizesAccessKey
? FuncDataTemplate.Access
: FuncDataTemplate.Default
);
if (dataTemplate is IRecyclingDataTemplate rdt)
{
var toRecycle = rdt == _recyclingDataTemplate ? oldChild : null;
newChild = rdt.Build(content, toRecycle);
_recyclingDataTemplate = rdt;
}
else
{
newChild = dataTemplate.Build(content);
_recyclingDataTemplate = null;
}
}
else
{
_recyclingDataTemplate = null;
}
return newChild;
}
/// <inheritdoc/>
protected override Size MeasureOverride(Size availableSize)
{
return LayoutHelper.MeasureChild(Child, availableSize, Padding, BorderThickness);
}
/// <inheritdoc/>
protected override Size ArrangeOverride(Size finalSize)
{
return ArrangeOverrideImpl(finalSize, new Vector());
}
internal Size ArrangeOverrideImpl(Size finalSize, Vector offset)
{
if (Child == null) return finalSize;
var useLayoutRounding = UseLayoutRounding;
var scale = LayoutHelper.GetLayoutScale(this);
var padding = Padding;
var borderThickness = BorderThickness;
if (useLayoutRounding)
{
padding = LayoutHelper.RoundLayoutThickness(padding, scale);
borderThickness = LayoutHelper.RoundLayoutThickness(borderThickness, scale);
}
padding += borderThickness;
var horizontalContentAlignment = HorizontalContentAlignment;
var verticalContentAlignment = VerticalContentAlignment;
var availableSize = finalSize;
var sizeForChild = availableSize;
var originX = offset.X;
var originY = offset.Y;
if (horizontalContentAlignment != HorizontalAlignment.Stretch)
{
sizeForChild = sizeForChild.WithWidth(Math.Min(sizeForChild.Width, DesiredSize.Width));
}
if (verticalContentAlignment != VerticalAlignment.Stretch)
{
sizeForChild = sizeForChild.WithHeight(Math.Min(sizeForChild.Height, DesiredSize.Height));
}
if (useLayoutRounding)
{
sizeForChild = LayoutHelper.RoundLayoutSizeUp(sizeForChild, scale);
availableSize = LayoutHelper.RoundLayoutSizeUp(availableSize, scale);
}
switch (horizontalContentAlignment)
{
case HorizontalAlignment.Center:
originX += (availableSize.Width - sizeForChild.Width) / 2;
break;
case HorizontalAlignment.Right:
originX += availableSize.Width - sizeForChild.Width;
break;
}
switch (verticalContentAlignment)
{
case VerticalAlignment.Center:
originY += (availableSize.Height - sizeForChild.Height) / 2;
break;
case VerticalAlignment.Bottom:
originY += availableSize.Height - sizeForChild.Height;
break;
}
var origin = new Point(originX, originY);
if (useLayoutRounding)
{
origin = LayoutHelper.RoundLayoutPoint(origin, scale);
}
var boundsForChild = new Rect(origin, sizeForChild).Deflate(padding);
Child.Arrange(boundsForChild);
return finalSize;
}
/// <summary>
/// Called when the <see cref="Content"/> property changes.
/// </summary>
/// <param name="e">The event args.</param>
private void ContentChanged(AvaloniaPropertyChangedEventArgs e)
{
_createdChild = false;
if (((ILogical)this).IsAttachedToLogicalTree)
{
if (e.Property.Name == nameof(Content))
{
UpdateChild(e.NewValue);
}
else
{
UpdateChild();
}
}
else if (Child != null)
{
VisualChildren.Remove(Child);
GetEffectiveLogicalChildren().Remove(Child);
((ISetInheritanceParent)Child).SetParent(Child.Parent);
Child = null;
_recyclingDataTemplate = null;
}
UpdatePseudoClasses();
InvalidateMeasure();
}
private void UpdatePseudoClasses()
{
PseudoClasses.Set(":empty", Content is null);
}
private void TemplatedParentChanged(AvaloniaPropertyChangedEventArgs e)
{
var host = e.NewValue as IContentPresenterHost;
Host = host?.RegisterContentPresenter(this) == true ? host : null;
}
internal override void BuildDebugDisplay(StringBuilder builder, bool includeContent)
{
base.BuildDebugDisplay(builder, includeContent);
DebugDisplayHelper.AppendOptionalValue(builder, nameof(Host), Host, false);
if (includeContent)
{
DebugDisplayHelper.AppendOptionalValue(builder, nameof(Content), Content, true);
}
}
}
}
| ContentPresenter |
csharp | dotnet__machinelearning | src/Microsoft.ML.Data/DataView/CacheDataView.cs | {
"start": 31739,
"end": 32946
} | private interface ____
{
long Batch { get; }
/// <summary>
/// The index. Callers should never call this either before one of the move
/// methods has returned true, or ever after either has returned false.
/// </summary>
long GetIndex();
/// <summary>
/// An ID getter, which should be based on the value that would be returned
/// from <see cref="GetIndex"/>, if valid, and otherwise have undefined behavior.
/// </summary>
ValueGetter<DataViewRowId> GetIdGetter();
/// <summary>
/// Moves to the next index. Once this has returned false, it should never be called again.
/// (This in constrast to public <see cref="DataViewRowCursor"/> objects, whose move methods are
/// robust to that usage.)
/// </summary>
/// <returns>Whether the next index is available.</returns>
bool MoveNext();
}
/// <summary>
/// An <see cref="IIndex"/> where the indices, while valid, are sequential increasing
/// adjacent indices.
/// </summary>
| IIndex |
csharp | MassTransit__MassTransit | src/MassTransit/SagaStateMachine/ScheduleDateTimeExtensions.cs | {
"start": 110,
"end": 3599
} | public static class ____
{
public static EventActivityBinder<TInstance> Schedule<TInstance, TMessage>(this EventActivityBinder<TInstance> source,
Schedule<TInstance, TMessage> schedule, TMessage message, ScheduleTimeProvider<TInstance> timeProvider,
Action<SendContext<TMessage>> callback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return source.Add(new ScheduleActivity<TInstance, TMessage>(schedule, timeProvider, MessageFactory<TMessage>.Create(message, callback)));
}
public static EventActivityBinder<TInstance> Schedule<TInstance, TMessage>(this EventActivityBinder<TInstance> source,
Schedule<TInstance, TMessage> schedule, Task<TMessage> message, ScheduleTimeProvider<TInstance> timeProvider,
Action<SendContext<TMessage>> callback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return source.Add(new ScheduleActivity<TInstance, TMessage>(schedule, timeProvider, MessageFactory<TMessage>.Create(message, callback)));
}
public static EventActivityBinder<TInstance> Schedule<TInstance, TMessage>(this EventActivityBinder<TInstance> source,
Schedule<TInstance, TMessage> schedule, EventMessageFactory<TInstance, TMessage> messageFactory, ScheduleTimeProvider<TInstance> timeProvider,
Action<SendContext<TMessage>> callback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return source.Add(new ScheduleActivity<TInstance, TMessage>(schedule, timeProvider, MessageFactory<TMessage>.Create(messageFactory, callback)));
}
public static EventActivityBinder<TInstance> Schedule<TInstance, TMessage>(this EventActivityBinder<TInstance> source,
Schedule<TInstance, TMessage> schedule, AsyncEventMessageFactory<TInstance, TMessage> messageFactory, ScheduleTimeProvider<TInstance> timeProvider,
Action<SendContext<TMessage>> callback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return source.Add(new ScheduleActivity<TInstance, TMessage>(schedule, timeProvider, MessageFactory<TMessage>.Create(messageFactory, callback)));
}
public static EventActivityBinder<TInstance> Schedule<TInstance, TMessage>(this EventActivityBinder<TInstance> source,
Schedule<TInstance, TMessage> schedule, Func<BehaviorContext<TInstance>, Task<SendTuple<TMessage>>> messageFactory,
ScheduleTimeProvider<TInstance> timeProvider, Action<SendContext<TMessage>> callback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return source.Add(new ScheduleActivity<TInstance, TMessage>(schedule, timeProvider, MessageFactory<TMessage>.Create(messageFactory, callback)));
}
public static EventActivityBinder<TInstance, TData> Schedule<TInstance, TData, TMessage>(this EventActivityBinder<TInstance, TData> source,
Schedule<TInstance, TMessage> schedule, TMessage message, ScheduleTimeProvider<TInstance, TData> timeProvider,
Action<SendContext<TMessage>> callback = null)
where TInstance : class, SagaStateMachineInstance
where TData : | ScheduleDateTimeExtensions |
csharp | dotnet__efcore | test/EFCore.Specification.Tests/ModelBuilding101OneToManyNrtTestBase.cs | {
"start": 8181,
"end": 8312
} | public class ____
{
public int Id { get; set; }
public Blog? Blog { get; set; }
}
| Post |
csharp | jellyfin__jellyfin | src/Jellyfin.Networking/Udp/SocketFactory.cs | {
"start": 150,
"end": 210
} | class ____ create different kinds of sockets.
/// </summary>
| to |
csharp | EventStore__EventStore | src/KurrentDB.Projections.Core/Services/Processing/StagedProcessingQueue.cs | {
"start": 1576,
"end": 8677
} | private class ____ {
public TaskEntry Entry;
public StageEntry Next;
}
private readonly bool[] _orderedStage;
private readonly Dictionary<object, TaskEntry> _correlationLastEntries = new Dictionary<object, TaskEntry>();
private StageEntry[] _byUnorderedStageFirst; // null means all processed? so append need to set it?
private StageEntry[] _byUnorderedStageLast; // null means all processed? so append need to set it?
private TaskEntry[] _byOrderedStageLast; // null means all processed? so append need to set it?
private long _sequence = 0;
private TaskEntry _first;
private TaskEntry _last;
private int _count;
private readonly int _maxStage;
public event Action EnsureTickPending;
public StagedProcessingQueue(bool[] orderedStage) {
_orderedStage = orderedStage.ToArray();
_byUnorderedStageFirst = new StageEntry[_orderedStage.Length];
_byUnorderedStageLast = new StageEntry[_orderedStage.Length];
_byOrderedStageLast = new TaskEntry[_orderedStage.Length];
_maxStage = _orderedStage.Length - 1;
}
public int Count {
get { return _count; }
}
public void Enqueue(StagedTask stagedTask) {
var entry = new TaskEntry(stagedTask, ++_sequence);
if (_first == null) {
_first = entry;
_last = entry;
_count = 1;
} else {
_last.Next = entry;
_last = entry;
_count++;
}
// re-initialize already completed queues
for (var stage = 0; stage <= _maxStage; stage++)
if (_orderedStage[stage] && _byOrderedStageLast[stage] == null)
_byOrderedStageLast[stage] = entry;
SetEntryCorrelation(entry, stagedTask.InitialCorrelationId);
EnqueueForStage(entry, 0);
}
public bool Process(int max = 1) {
int processed = 0;
int fromStage = _maxStage;
while (_count > 0 && processed < max) {
RemoveCompleted();
var entry = GetEntryToProcess(fromStage);
if (entry == null)
break;
ProcessEntry(entry);
fromStage = entry.ReadForStage;
processed++;
}
return processed > 0;
}
private void ProcessEntry(TaskEntry entry) {
// here we should be at the first StagedTask of current processing level which is not busy
entry.Busy = true;
AdvanceStage(entry.ReadForStage, entry);
entry.Task.Process(
entry.ReadForStage,
(readyForStage, newCorrelationId) => CompleteTaskProcessing(entry, readyForStage, newCorrelationId));
}
private TaskEntry GetEntryToProcess(int fromStage) {
var stageIndex = fromStage;
while (stageIndex >= 0) {
TaskEntry task = null;
if (!_orderedStage[stageIndex]) {
if (_byUnorderedStageFirst[stageIndex] != null
&& _byUnorderedStageFirst[stageIndex].Entry.PreviousByCorrelation == null) {
var stageEntry = _byUnorderedStageFirst[stageIndex];
task = stageEntry.Entry;
}
} else {
var taskEntry = _byOrderedStageLast[stageIndex];
if (taskEntry != null && taskEntry.ReadForStage == stageIndex && !taskEntry.Busy
&& !taskEntry.Completed && taskEntry.PreviousByCorrelation == null)
task = taskEntry;
}
if (task == null) {
stageIndex--;
continue;
}
if (task.ReadForStage != stageIndex)
throw new Exception();
return task;
}
return null;
}
private void RemoveCompleted() {
while (_first != null && _first.Completed) {
var task = _first;
_first = task.Next;
if (_first == null)
_last = null;
_count--;
if (task.BusyCorrelationId != null) {
var nextByCorrelation = task.NextByCorrelation;
if (nextByCorrelation != null) {
if (nextByCorrelation.PreviousByCorrelation != task)
throw new Exception("Invalid linked list by correlation");
task.NextByCorrelation = null;
nextByCorrelation.PreviousByCorrelation = null;
if (!_orderedStage[nextByCorrelation.ReadForStage])
EnqueueForStage(nextByCorrelation, nextByCorrelation.ReadForStage);
} else {
// remove the last one
_correlationLastEntries.Remove(task.BusyCorrelationId);
}
}
}
}
private void CompleteTaskProcessing(TaskEntry entry, int readyForStage, object newCorrelationId) {
if (!entry.Busy)
throw new InvalidOperationException("Task was not in progress");
entry.Busy = false;
SetEntryCorrelation(entry, newCorrelationId);
if (readyForStage < 0) {
MarkCompletedTask(entry);
if (entry == _first)
RemoveCompleted();
} else
EnqueueForStage(entry, readyForStage);
if (EnsureTickPending != null)
EnsureTickPending();
}
private void EnqueueForStage(TaskEntry entry, int readyForStage) {
entry.ReadForStage = readyForStage;
if (!_orderedStage[readyForStage] && (entry.PreviousByCorrelation == null)) {
var stageEntry = new StageEntry { Entry = entry, Next = null };
if (_byUnorderedStageFirst[readyForStage] != null) {
_byUnorderedStageLast[readyForStage].Next = stageEntry;
_byUnorderedStageLast[readyForStage] = stageEntry;
} else {
_byUnorderedStageFirst[readyForStage] = stageEntry;
_byUnorderedStageLast[readyForStage] = stageEntry;
}
}
}
private void AdvanceStage(int stage, TaskEntry entry) {
if (!_orderedStage[stage]) {
if (_byUnorderedStageFirst[stage].Entry != entry)
throw new ArgumentException(
string.Format("entry is not a head of the queue at the stage {0}", stage), "entry");
_byUnorderedStageFirst[stage] = _byUnorderedStageFirst[stage].Next;
if (_byUnorderedStageFirst[stage] == null)
_byUnorderedStageLast[stage] = null;
} else {
if (_byOrderedStageLast[stage] != entry)
throw new ArgumentException(
string.Format("entry is not a head of the queue at the stage {0}", stage), "entry");
_byOrderedStageLast[stage] = entry.Next;
}
}
private void SetEntryCorrelation(TaskEntry entry, object newCorrelationId) {
if (!Equals(entry.BusyCorrelationId, newCorrelationId)) {
if (entry.ReadForStage != -1 && !_orderedStage[entry.ReadForStage])
throw new InvalidOperationException("Cannot set busy correlation id at non-ordered stage");
if (entry.BusyCorrelationId != null)
throw new InvalidOperationException("Busy correlation id has been already set");
entry.BusyCorrelationId = newCorrelationId;
if (newCorrelationId != null) {
TaskEntry lastEntry;
if (_correlationLastEntries.TryGetValue(newCorrelationId, out lastEntry)) {
if (entry.Sequence < lastEntry.Sequence)
//NOTE: should never happen as we require ordered stage or initialization
throw new InvalidOperationException(
"Cannot inject task correlation id before another task with the same correlation id");
lastEntry.NextByCorrelation = entry;
entry.PreviousByCorrelation = lastEntry;
_correlationLastEntries[newCorrelationId] = entry;
} else
_correlationLastEntries.Add(newCorrelationId, entry);
}
}
}
private void MarkCompletedTask(TaskEntry entry) {
entry.Completed = true;
}
public void Initialize() {
_correlationLastEntries.Clear();
_byUnorderedStageFirst = new StageEntry[_orderedStage.Length];
_byUnorderedStageLast = new StageEntry[_orderedStage.Length];
_byOrderedStageLast = new TaskEntry[_orderedStage.Length];
_count = 0;
_first = null;
_last = null;
}
}
| StageEntry |
csharp | dotnet__orleans | test/NonSilo.Tests/Caching/ConcurrentLruSoakTests.cs | {
"start": 12488,
"end": 13238
} | private sealed class ____ : Xunit.Sdk.DataAttribute
{
private readonly int _count;
public RepeatAttribute(int count)
{
if (count < 1)
{
throw new ArgumentOutOfRangeException(
paramName: nameof(count),
message: "Repeat count must be greater than 0."
);
}
_count = count;
}
public override IEnumerable<object[]> GetData(System.Reflection.MethodInfo testMethod)
{
foreach (var iterationNumber in Enumerable.Range(start: 1, count: _count))
{
yield return new object[] { iterationNumber };
}
}
}
| RepeatAttribute |
csharp | OrchardCMS__OrchardCore | src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Queries/PublicationStatusGraphType.cs | {
"start": 121,
"end": 727
} | public sealed class ____ : EnumerationGraphType
{
public PublicationStatusGraphType(IStringLocalizer<PublicationStatusGraphType> S)
{
Name = "Status";
Description = S["publication status"];
Add("PUBLISHED", PublicationStatusEnum.Published, S["published content item version"]);
Add("DRAFT", PublicationStatusEnum.Draft, S["draft content item version"]);
Add("LATEST", PublicationStatusEnum.Latest, S["the latest version, either published or draft"]);
Add("ALL", PublicationStatusEnum.All, S["all historical versions"]);
}
}
| PublicationStatusGraphType |
csharp | microsoft__semantic-kernel | dotnet/src/SemanticKernel.UnitTests/Events/FunctionInvokedEventArgsTests.cs | {
"start": 226,
"end": 1160
} | public class ____
{
[Fact]
public void ResultValuePropertyShouldBeInitializedByOriginalOne()
{
//Arrange
var originalResults = new FunctionResult(KernelFunctionFactory.CreateFromMethod(() => { }), 36, CultureInfo.InvariantCulture);
var sut = new FunctionInvokedEventArgs(KernelFunctionFactory.CreateFromMethod(() => { }), [], originalResults);
//Assert
Assert.Equal(36, sut.ResultValue);
}
[Fact]
public void ResultValuePropertyShouldBeUpdated()
{
//Arrange
var originalResults = new FunctionResult(KernelFunctionFactory.CreateFromMethod(() => { }), 36, CultureInfo.InvariantCulture);
var sut = new FunctionInvokedEventArgs(KernelFunctionFactory.CreateFromMethod(() => { }), [], originalResults);
//Act
sut.SetResultValue(72);
//Assert
Assert.Equal(72, sut.ResultValue);
}
}
| FunctionInvokedEventArgsTests |
csharp | dotnet__maui | src/Controls/tests/TestCases.HostApp/Issues/Bugzilla/Bugzilla27731.cs | {
"start": 641,
"end": 1120
} | class ____ : ContentPage
{
static int count;
public Page2(string title)
{
count++;
Title = $"{title}{count}";
NavigationPage.SetHasNavigationBar(this, false);
Content = new StackLayout
{
Children =
{
new Label { Text = $"This is page {count}.", AutomationId = "PageLabel" },
new Button { Text = "Click", AutomationId = "Click", Command = new Command(() => Navigation.PushAsync(new Page2(title))) }
}
};
}
}
}
} | Page2 |
csharp | CommunityToolkit__WindowsCommunityToolkit | Microsoft.Toolkit.Uwp.UI.Controls.DataGrid/DataGrid/DataGridInteractionInfo.cs | {
"start": 302,
"end": 539
} | internal class ____
{
internal uint CapturedPointerId
{
get;
set;
}
internal bool IsPointerOver
{
get;
set;
}
}
} | DataGridInteractionInfo |
csharp | OrchardCMS__OrchardCore | src/OrchardCore/OrchardCore.Abstractions/Localization/CalendarName.cs | {
"start": 68,
"end": 109
} | enum ____ calendar names.
/// </summary>
| for |
csharp | dotnet__aspnetcore | src/Validation/gen/Emitters/ValidationsGenerator.Emitter.cs | {
"start": 9075,
"end": 12665
} | record ____
foreach (var constructor in k.ContainingType.GetConstructors())
{
// Look for parameter with matching name (case insensitive)
var parameter = global::System.Linq.Enumerable.FirstOrDefault(
constructor.GetParameters(),
p => string.Equals(p.Name, k.PropertyName, global::System.StringComparison.OrdinalIgnoreCase));
if (parameter != null)
{
var paramAttributes = global::System.Reflection.CustomAttributeExtensions
.GetCustomAttributes<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(parameter, inherit: true);
results.AddRange(paramAttributes);
break;
}
}
return results.ToArray();
});
}
public static global::System.ComponentModel.DataAnnotations.ValidationAttribute[] GetTypeValidationAttributes(
[global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces)]
global::System.Type type
)
{
return TypeCache.GetOrAdd(type, static t =>
{
var typeAttributes = global::System.Reflection.CustomAttributeExtensions
.GetCustomAttributes<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(t, inherit: true);
return global::System.Linq.Enumerable.ToArray(typeAttributes);
});
}
}
}
""";
private static string EmitTypeChecks(ImmutableArray<ValidatableType> validatableTypes)
{
var sw = new StringWriter();
var cw = new CodeWriter(sw, baseIndent: 3);
foreach (var validatableType in validatableTypes)
{
var typeName = validatableType.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
cw.WriteLine($"if (type == typeof({typeName}))");
cw.StartBlock();
cw.WriteLine($"validatableInfo = new GeneratedValidatableTypeInfo(");
cw.Indent++;
cw.WriteLine($"type: typeof({typeName}),");
if (validatableType.Members.IsDefaultOrEmpty)
{
cw.WriteLine("members: []");
}
else
{
cw.WriteLine("members: [");
cw.Indent++;
foreach (var member in validatableType.Members)
{
EmitValidatableMemberForCreate(member, cw);
}
cw.Indent--;
cw.WriteLine("]");
}
cw.Indent--;
cw.WriteLine(");");
cw.WriteLine("return true;");
cw.EndBlock();
}
return sw.ToString();
}
private static void EmitValidatableMemberForCreate(ValidatableProperty member, CodeWriter cw)
{
cw.WriteLine("new GeneratedValidatablePropertyInfo(");
cw.Indent++;
cw.WriteLine($"containingType: typeof({member.ContainingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}),");
cw.WriteLine($"propertyType: typeof({member.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}),");
cw.WriteLine($"name: \"{member.Name}\",");
cw.WriteLine($"displayName: \"{member.DisplayName}\"");
cw.Indent--;
cw.WriteLine("),");
}
}
| scenarios |
csharp | microsoft__PowerToys | src/modules/cmdpal/Microsoft.CmdPal.UI/Helpers/TypedEventHandlerExtensions.cs | {
"start": 459,
"end": 3681
} | public static class ____
{
/// <summary>
/// Use to invoke an async <see cref="TypedEventHandler{TSender, TResult}"/> using <see cref="DeferredEventArgs"/>.
/// </summary>
/// <typeparam name="S">Type of sender.</typeparam>
/// <typeparam name="R"><see cref="EventArgs"/> type.</typeparam>
/// <param name="eventHandler"><see cref="TypedEventHandler{TSender, TResult}"/> to be invoked.</param>
/// <param name="sender">Sender of the event.</param>
/// <param name="eventArgs"><see cref="EventArgs"/> instance.</param>
/// <returns><see cref="Task"/> to wait on deferred event handler.</returns>
#pragma warning disable CA1715 // Identifiers should have correct prefix
#pragma warning disable SA1314 // Type parameter names should begin with T
public static Task InvokeAsync<S, R>(this TypedEventHandler<S, R> eventHandler, S sender, R eventArgs)
#pragma warning restore SA1314 // Type parameter names should begin with T
#pragma warning restore CA1715 // Identifiers should have correct prefix
where R : DeferredEventArgs => InvokeAsync(eventHandler, sender, eventArgs, CancellationToken.None);
/// <summary>
/// Use to invoke an async <see cref="TypedEventHandler{TSender, TResult}"/> using <see cref="DeferredEventArgs"/> with a <see cref="CancellationToken"/>.
/// </summary>
/// <typeparam name="S">Type of sender.</typeparam>
/// <typeparam name="R"><see cref="EventArgs"/> type.</typeparam>
/// <param name="eventHandler"><see cref="TypedEventHandler{TSender, TResult}"/> to be invoked.</param>
/// <param name="sender">Sender of the event.</param>
/// <param name="eventArgs"><see cref="EventArgs"/> instance.</param>
/// <param name="cancellationToken"><see cref="CancellationToken"/> option.</param>
/// <returns><see cref="Task"/> to wait on deferred event handler.</returns>
#pragma warning disable CA1715 // Identifiers should have correct prefix
#pragma warning disable SA1314 // Type parameter names should begin with T
public static Task InvokeAsync<S, R>(this TypedEventHandler<S, R> eventHandler, S sender, R eventArgs, CancellationToken cancellationToken)
#pragma warning restore SA1314 // Type parameter names should begin with T
#pragma warning restore CA1715 // Identifiers should have correct prefix
where R : DeferredEventArgs
{
if (eventHandler is null)
{
return Task.CompletedTask;
}
var tasks = eventHandler.GetInvocationList()
.OfType<TypedEventHandler<S, R>>()
.Select(invocationDelegate =>
{
if (cancellationToken.IsCancellationRequested)
{
return Task.FromCanceled(cancellationToken);
}
invocationDelegate(sender, eventArgs);
#pragma warning disable CS0618 // Type or member is obsolete
var deferral = eventArgs.GetCurrentDeferralAndReset();
return deferral?.WaitForCompletion(cancellationToken) ?? Task.CompletedTask;
#pragma warning restore CS0618 // Type or member is obsolete
})
.ToArray();
return Task.WhenAll(tasks);
}
}
| TypedEventHandlerExtensions |
csharp | dotnet__orleans | src/api/Orleans.Transactions.TestKit.Base/Orleans.Transactions.TestKit.Base.cs | {
"start": 182588,
"end": 184591
} | partial class ____ : global::Orleans.TransactionTaskRequest
{
public System.Collections.Generic.List<global::Orleans.Transactions.TestKit.ITransactionTestGrain> arg0;
public System.Collections.Generic.List<global::Orleans.Transactions.TestKit.ITransactionTestGrain> arg1;
public int arg2;
public Invokable_ITransactionCoordinatorGrain_GrainReference_2760260D(global::Orleans.Serialization.Serializer<global::Orleans.Transactions.OrleansTransactionAbortedException> base0, System.IServiceProvider base1) : base(default(Serialization.Serializer<Transactions.OrleansTransactionAbortedException>)!, default!) { }
public override void Dispose() { }
public override string GetActivityName() { throw null; }
public override object GetArgument(int index) { throw null; }
public override int GetArgumentCount() { throw null; }
public override string GetInterfaceName() { throw null; }
public override System.Type GetInterfaceType() { throw null; }
public override System.Reflection.MethodInfo GetMethod() { throw null; }
public override string GetMethodName() { throw null; }
public override object GetTarget() { throw null; }
protected override System.Threading.Tasks.Task InvokeInner() { throw null; }
public override void SetArgument(int index, object value) { }
public override void SetTarget(global::Orleans.Serialization.Invocation.ITargetHolder holder) { }
}
[System.CodeDom.Compiler.GeneratedCode("OrleansCodeGen", "9.0.0.0")]
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
[global::Orleans.CompoundTypeAlias(new[] { "inv", typeof(global::Orleans.Runtime.GrainReference), typeof(global::Orleans.Transactions.TestKit.ITransactionCoordinatorGrain), "3A6B9237" })]
public sealed | Invokable_ITransactionCoordinatorGrain_GrainReference_2760260D |
csharp | dotnet__BenchmarkDotNet | src/BenchmarkDotNet/Configs/ImmutableConfig.cs | {
"start": 610,
"end": 6427
} | public sealed class ____ : IConfig
{
// if something is an array here instead of hashset it means it must have a guaranteed order of elements
private readonly ImmutableArray<IColumnProvider> columnProviders;
private readonly ImmutableArray<IExporter> exporters;
private readonly ImmutableHashSet<ILogger> loggers;
private readonly ImmutableHashSet<IDiagnoser> diagnosers;
private readonly ImmutableHashSet<IAnalyser> analysers;
private readonly ImmutableHashSet<IValidator> validators;
private readonly ImmutableHashSet<Job> jobs;
private readonly ImmutableHashSet<HardwareCounter> hardwareCounters;
private readonly ImmutableHashSet<IFilter> filters;
private readonly ImmutableArray<BenchmarkLogicalGroupRule> rules;
private readonly ImmutableHashSet<EventProcessor> eventProcessors;
private readonly ImmutableArray<IColumnHidingRule> columnHidingRules;
internal ImmutableConfig(
ImmutableArray<IColumnProvider> uniqueColumnProviders,
ImmutableHashSet<ILogger> uniqueLoggers,
ImmutableHashSet<HardwareCounter> uniqueHardwareCounters,
ImmutableHashSet<IDiagnoser> uniqueDiagnosers,
ImmutableArray<IExporter> uniqueExporters,
ImmutableHashSet<IAnalyser> uniqueAnalyzers,
ImmutableHashSet<IValidator> uniqueValidators,
ImmutableHashSet<IFilter> uniqueFilters,
ImmutableArray<BenchmarkLogicalGroupRule> uniqueRules,
ImmutableArray<IColumnHidingRule> uniqueColumnHidingRules,
ImmutableHashSet<Job> uniqueRunnableJobs,
ImmutableHashSet<EventProcessor> uniqueEventProcessors,
ConfigUnionRule unionRule,
string artifactsPath,
CultureInfo cultureInfo,
IOrderer orderer,
ICategoryDiscoverer categoryDiscoverer,
SummaryStyle summaryStyle,
ConfigOptions options,
TimeSpan buildTimeout,
WakeLockType wakeLock,
IReadOnlyList<Conclusion> configAnalysisConclusion)
{
columnProviders = uniqueColumnProviders;
loggers = uniqueLoggers;
hardwareCounters = uniqueHardwareCounters;
diagnosers = uniqueDiagnosers;
exporters = uniqueExporters;
analysers = uniqueAnalyzers;
validators = uniqueValidators;
filters = uniqueFilters;
rules = uniqueRules;
columnHidingRules = uniqueColumnHidingRules;
jobs = uniqueRunnableJobs;
eventProcessors = uniqueEventProcessors;
UnionRule = unionRule;
ArtifactsPath = artifactsPath;
CultureInfo = cultureInfo;
Orderer = orderer;
CategoryDiscoverer = categoryDiscoverer;
SummaryStyle = summaryStyle;
Options = options;
BuildTimeout = buildTimeout;
WakeLock = wakeLock;
ConfigAnalysisConclusion = configAnalysisConclusion;
}
public ConfigUnionRule UnionRule { get; }
public string ArtifactsPath { get; }
public CultureInfo CultureInfo { get; }
public ConfigOptions Options { get; }
public IOrderer Orderer { get; }
public ICategoryDiscoverer CategoryDiscoverer { get; }
public SummaryStyle SummaryStyle { get; }
public TimeSpan BuildTimeout { get; }
public WakeLockType WakeLock { get; }
public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
public IEnumerable<IExporter> GetExporters() => exporters;
public IEnumerable<ILogger> GetLoggers() => loggers;
public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
public IEnumerable<IAnalyser> GetAnalysers() => analysers;
public IEnumerable<Job> GetJobs() => jobs;
public IEnumerable<IValidator> GetValidators() => validators;
public IEnumerable<HardwareCounter> GetHardwareCounters() => hardwareCounters;
public IEnumerable<IFilter> GetFilters() => filters;
public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => rules;
public IEnumerable<EventProcessor> GetEventProcessors() => eventProcessors;
public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => columnHidingRules;
public ILogger GetCompositeLogger() => new CompositeLogger(loggers);
public IExporter GetCompositeExporter() => new CompositeExporter(exporters);
public IValidator GetCompositeValidator() => new CompositeValidator(validators);
public IAnalyser GetCompositeAnalyser() => new CompositeAnalyser(analysers);
public IDiagnoser GetCompositeDiagnoser() => new CompositeDiagnoser(diagnosers);
public bool HasMemoryDiagnoser() => diagnosers.OfType<MemoryDiagnoser>().Any();
public bool HasThreadingDiagnoser() => diagnosers.Contains(ThreadingDiagnoser.Default);
public bool HasExceptionDiagnoser() => diagnosers.Contains(ExceptionDiagnoser.Default);
internal bool HasPerfCollectProfiler() => diagnosers.OfType<PerfCollectProfiler>().Any();
public bool HasExtraStatsDiagnoser() => HasMemoryDiagnoser() || HasThreadingDiagnoser() || HasExceptionDiagnoser();
public IDiagnoser? GetCompositeDiagnoser(BenchmarkCase benchmarkCase, RunMode runMode)
{
var diagnosersForGivenMode = diagnosers.Where(diagnoser => diagnoser.GetRunMode(benchmarkCase) == runMode).ToImmutableHashSet();
return diagnosersForGivenMode.Any() ? new CompositeDiagnoser(diagnosersForGivenMode) : null;
}
public IReadOnlyList<Conclusion> ConfigAnalysisConclusion { get; private set; }
}
}
| ImmutableConfig |
csharp | getsentry__sentry-dotnet | src/Sentry/Platforms/Cocoa/SentryOptions.cs | {
"start": 13587,
"end": 18974
} | public class ____
{
/// <summary>
/// <para>
/// Forces enabling of session replay in unreliable environments.
/// </para>
/// <para>
/// Due to internal changes with the release of Liquid Glass on iOS 26.0, the masking of text and images can
/// not be reliably guaranteed. Therefore the SDK uses a defensive programming approach to disable the
/// session replay integration by default, unless the environment is detected as reliable.
/// </para>
/// <para>
/// Indicators for reliable environments include:
/// <list type="bullet">
/// <item>
/// <description>Running on an older version of iOS that doesn't have Liquid Glass (iOS 18 or earlier)</description>
/// </item>
/// <item>
/// <description><c>UIDesignRequiresCompatibility</c> is explicitly set to <c>YES</c> in <c>Info.plist</c></description>
/// </item>
/// <item>
/// <description>The app was built with Xcode < 26.0 (DTXcode < 2600)</description>
/// </item>
/// </list>
/// </para>
/// <para>
/// Important: This flag allows to re-enable the session replay integration on iOS 26.0 and later, but please be aware that text and images may not be masked as expected.
/// </para>
/// </summary>
/// <remarks>
/// See https://github.com/getsentry/sentry-cocoa/issues/6389
/// </remarks>
public bool EnableSessionReplayInUnreliableEnvironment { get; set; } = false;
/// <summary>
/// The sample rate for sessions that had an error or crash.
/// Value must be between 0.0 and 1.0.
/// A value of 0.0 disables session replay for errored sessions.
/// A value of 1.0 captures session replay for all errored sessions.
/// </summary>
public double? OnErrorSampleRate { get; set; }
/// <summary>
/// The sample rate for all sessions.
/// Value must be between 0.0 and 1.0.
/// A value of 0.0 disables session replay for all sessions.
/// A value of 1.0 captures session replay for all sessions.
/// </summary>
public double? SessionSampleRate { get; set; }
/// <summary>
/// Whether to mask all images in the session replay by default.
/// </summary>
public bool MaskAllImages { get; set; } = true;
/// <summary>
/// Whether to mask all text in the session replay by default.
/// </summary>
public bool MaskAllText { get; set; } = true;
/// <summary>
/// When enabled, reduces the impact of Session Replay on the main thread and potential frame drops. This is
/// the default and recommended setting, but if you are experiencing issues then you can opt out by setting
/// to <c>false</c>.
/// </summary>
/// <remarks>Defaults to <c>true</c></remarks>
public bool EnableViewRendererV2 { get; set; } = true;
/// <summary>
/// <para>
/// Enables faster rendering of views at the cost of some visual fidelity.
/// </para>
/// <para>
/// See: https://blog.sentry.io/boosting-session-replay-performance-on-ios-with-view-renderer-v2/
/// </para>
/// </summary>
/// <remarks>Defaults to <c>false</c></remarks>
public bool EnableFastViewRendering { get; set; } = false;
internal bool IsSessionReplayEnabled => OnErrorSampleRate > 0.0 || SessionSampleRate > 0.0;
}
/// <summary>
/// ExperimentalOptions
/// </summary>
public NativeExperimentalOptions ExperimentalOptions { get; set; } = new();
}
// We actually add the profiling integration automatically in InitSentryCocoaSdk().
// However, if user calls AddProfilingIntegration() multiple times, we print a warning, as usual.
private bool _profilingIntegrationAddedByUser = false;
/// <summary>
/// Adds ProfilingIntegration to Sentry.
/// </summary>
/// <param name="startupTimeout">
/// Unused, only here so that the signature is the same as AddProfilingIntegration() from package Sentry.Profiling.
/// </param>
public void AddProfilingIntegration(TimeSpan startupTimeout = default)
{
if (HasIntegration<ProfilingIntegration>())
{
if (_profilingIntegrationAddedByUser)
{
DiagnosticLogger?.LogWarning($"{nameof(ProfilingIntegration)} has already been added. The second call to {nameof(AddProfilingIntegration)} will be ignored.");
}
return;
}
_profilingIntegrationAddedByUser = true;
AddIntegration(new ProfilingIntegration());
}
/// <summary>
/// Disables the Profiling integration.
/// </summary>
public void DisableProfilingIntegration()
{
_profilingIntegrationAddedByUser = false;
RemoveIntegration<ProfilingIntegration>();
}
}
| NativeSentryReplayOptions |
csharp | MassTransit__MassTransit | src/MassTransit.Abstractions/Serialization/EmptyMessageBody.cs | {
"start": 51,
"end": 489
} | public class ____ :
MessageBody
{
public static MessageBody Instance { get; } = new EmptyMessageBody();
public long? Length => 0;
public Stream GetStream()
{
return new MemoryStream();
}
public byte[] GetBytes()
{
return [];
}
public string GetString()
{
return string.Empty;
}
}
}
| EmptyMessageBody |
csharp | abpframework__abp | framework/src/Volo.Abp.VirtualFileSystem/Volo/Abp/VirtualFileSystem/DynamicFileProvider.cs | {
"start": 2408,
"end": 2805
} | protected struct ____
{
public ChangeTokenInfo(
CancellationTokenSource tokenSource,
CancellationChangeToken changeToken)
{
TokenSource = tokenSource;
ChangeToken = changeToken;
}
public CancellationTokenSource TokenSource { get; }
public CancellationChangeToken ChangeToken { get; }
}
}
| ChangeTokenInfo |
csharp | smartstore__Smartstore | src/Smartstore.Modules/Smartstore.PayPal/Components/PayPalViewComponentBase.cs | {
"start": 135,
"end": 1193
} | public abstract class ____ : SmartViewComponent
{
private PayPalSettings _settings;
private string _routeIdent;
protected PayPalSettings Settings
{
get => _settings ??= Services.Resolve<PayPalSettings>();
}
protected string RouteIdent
{
get => _routeIdent ??= Request.RouteValues.GenerateRouteIdentifier();
}
/// <summary>
/// Renders PayPal buttons widget.
/// </summary>
public Task<IViewComponentResult> InvokeAsync()
{
// If client id or secret haven't been configured yet, don't render buttons.
if (!Settings.ClientId.HasValue() || !Settings.Secret.HasValue())
{
return Task.FromResult(Empty());
}
return InvokeCoreAsync();
}
protected virtual Task<IViewComponentResult> InvokeCoreAsync()
=> Task.FromResult(InvokeCore());
protected abstract IViewComponentResult InvokeCore();
}
} | PayPalViewComponentBase |
csharp | unoplatform__uno | src/Uno.UI/UI/Xaml/Controls/WrapPanel/NumericExtensions.cs | {
"start": 334,
"end": 3405
} | internal static class ____
{
/// <summary>
/// Check if a number is zero.
/// </summary>
/// <param name="value">The number to check.</param>
/// <returns>True if the number is zero, false otherwise.</returns>
public static bool IsZero(this double value)
{
// We actually consider anything within an order of magnitude of
// epsilon to be zero
return Math.Abs(value) < 2.2204460492503131E-15;
}
public static bool IsOne(this double value)
{
// We actually consider anything within an order of magnitude of
// epsilon to be zero
return Math.Abs(value - 1.0) < 2.2204460492503131E-15;
}
/// <summary>
/// Check if a number isn't really a number.
/// </summary>
/// <param name="value">The number to check.</param>
/// <returns>
/// True if the number is not a number, false if it is a number.
/// </returns>
public static bool IsNaN(this double value)
{
// Get the double as an unsigned long
NanUnion union = new NanUnion { FloatingValue = value };
// An IEEE 754 double precision floating point number is NaN if its
// exponent equals 2047 and it has a non-zero mantissa.
ulong exponent = union.IntegerValue & 0xfff0000000000000L;
if ((exponent != 0x7ff0000000000000L) && (exponent != 0xfff0000000000000L))
{
return false;
}
ulong mantissa = union.IntegerValue & 0x000fffffffffffffL;
return mantissa != 0L;
}
/// <summary>
/// Determine if one number is greater than another.
/// </summary>
/// <param name="left">First number.</param>
/// <param name="right">Second number.</param>
/// <returns>
/// True if the first number is greater than the second, false
/// otherwise.
/// </returns>
public static bool IsGreaterThan(double left, double right)
{
return (left > right) && !AreClose(left, right);
}
/// <summary>
/// Determine if one number is less than or close to another.
/// </summary>
/// <param name="left">First number.</param>
/// <param name="right">Second number.</param>
/// <returns>
/// True if the first number is less than or close to the second, false
/// otherwise.
/// </returns>
public static bool IsLessThanOrClose(double left, double right)
{
return (left < right) || AreClose(left, right);
}
/// <summary>
/// Determine if two numbers are close in value.
/// </summary>
/// <param name="left">First number.</param>
/// <param name="right">Second number.</param>
/// <returns>
/// True if the first number is close in value to the second, false
/// otherwise.
/// </returns>
public static bool AreClose(double left, double right)
{
if (left == right)
{
return true;
}
double a = (Math.Abs(left) + Math.Abs(right) + 10.0) * 2.2204460492503131E-16;
double b = left - right;
return (-a < b) && (a > b);
}
/// <summary>
/// NanUnion is a C++ style type union used for efficiently converting
/// a double into an unsigned long, whose bits can be easily
/// manipulated.
/// </summary>
[StructLayout(LayoutKind.Explicit)]
| NumericExtensions |
csharp | dotnet__aspnetcore | src/Mvc/Mvc.TagHelpers/src/ModeAttributesOfT.cs | {
"start": 447,
"end": 1207
} | internal sealed class ____<TMode>
{
/// <summary>
/// Initializes a new instance of <see cref="ModeAttributes{TMode}"/>.
/// </summary>
/// <param name="mode">The <see cref="AspNetCore.Razor.TagHelpers.ITagHelper"/>'s mode.</param>
/// <param name="attributes">The names of attributes required for this mode.</param>
public ModeAttributes(TMode mode, string[] attributes)
{
Mode = mode;
Attributes = attributes;
}
/// <summary>
/// Gets the <see cref="AspNetCore.Razor.TagHelpers.ITagHelper"/>'s mode.
/// </summary>
public TMode Mode { get; }
/// <summary>
/// Gets the names of attributes required for this mode.
/// </summary>
public string[] Attributes { get; }
}
| ModeAttributes |
csharp | dotnet__tye | src/Microsoft.Tye.Core/IYamlManifestOutput.cs | {
"start": 274,
"end": 362
} | internal interface ____
{
YamlDocument Yaml { get; }
}
}
| IYamlManifestOutput |
csharp | icsharpcode__ILSpy | ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemTestCase.cs | {
"start": 13837,
"end": 13980
} | public interface ____
{
void M(int a);
int P { get; set; }
event Action E;
int this[int x] { get; set; }
}
| IExplicitImplementationTests |
csharp | dotnet__efcore | test/EFCore.SqlServer.Tests/ValueGeneration/SqlServerValueGeneratorCacheTest.cs | {
"start": 15846,
"end": 17002
} | private class ____
{
public int Id { get; set; }
}
private static IProperty GetProperty1(IModel model)
=> model.FindEntityType(typeof(Led)).FindProperty("Zeppelin");
private static IProperty GetProperty2(IModel model)
=> model.FindEntityType(typeof(Led)).FindProperty("Stairway");
private static IProperty GetProperty3(IModel model)
=> model.FindEntityType(typeof(Led)).FindProperty("WholeLotta");
private static IModel CreateModel()
{
var modelBuilder = SqlServerTestHelpers.Instance.CreateConventionBuilder();
modelBuilder.HasSequence("Heaven");
modelBuilder.HasSequence("Rosie");
modelBuilder.Entity<Led>(b =>
{
b.Property<int>("Id");
b.Property(e => e.Zeppelin).UseHiLo("Heaven");
b.HasAlternateKey(e => e.Zeppelin);
b.Property(e => e.Stairway).UseHiLo("Heaven");
b.HasAlternateKey(e => e.Stairway);
b.Property(e => e.WholeLotta).UseHiLo("Rosie");
b.HasAlternateKey(e => e.WholeLotta);
});
return modelBuilder.Model.FinalizeModel();
}
| Robot |
csharp | OrchardCMS__OrchardCore | src/OrchardCore/OrchardCore.Data.YesSql/Migration/DataMigrationManager.cs | {
"start": 334,
"end": 3564
} | public class ____ : IDataMigrationManager
{
private const string _updateFromPrefix = "UpdateFrom";
private const string _asyncSuffix = "Async";
private readonly IEnumerable<IDataMigration> _dataMigrations;
private readonly ISession _session;
private readonly IStore _store;
private readonly IExtensionManager _extensionManager;
private readonly ILogger _logger;
private readonly ITypeFeatureProvider _typeFeatureProvider;
private readonly List<string> _processedFeatures;
private DataMigrationRecord _dataMigrationRecord;
/// <summary>
/// Creates a new instance of the <see cref="DataMigrationManager"/>.
/// </summary>
/// <param name="typeFeatureProvider">The <see cref="ITypeFeatureProvider"/>.</param>
/// <param name="dataMigrations">A list of <see cref="IDataMigration"/>.</param>
/// <param name="session">The <see cref="ISession"/>.</param>
/// <param name="store">The <see cref="IStore"/>.</param>
/// <param name="extensionManager">The <see cref="IExtensionManager"/>.</param>
/// <param name="logger">The <see cref="ILogger"/>.</param>
public DataMigrationManager(
ITypeFeatureProvider typeFeatureProvider,
IEnumerable<IDataMigration> dataMigrations,
ISession session,
IStore store,
IExtensionManager extensionManager,
ILogger<DataMigrationManager> logger)
{
_typeFeatureProvider = typeFeatureProvider;
_dataMigrations = dataMigrations;
_session = session;
_store = store;
_extensionManager = extensionManager;
_logger = logger;
_processedFeatures = [];
}
/// <inheritdocs />
public async Task<DataMigrationRecord> GetDataMigrationRecordAsync()
{
if (_dataMigrationRecord == null)
{
_dataMigrationRecord = await _session.Query<DataMigrationRecord>().FirstOrDefaultAsync();
if (_dataMigrationRecord == null)
{
_dataMigrationRecord = new DataMigrationRecord();
await _session.SaveAsync(_dataMigrationRecord);
}
}
return _dataMigrationRecord;
}
public async Task<IEnumerable<string>> GetFeaturesThatNeedUpdateAsync()
{
var currentVersions = (await GetDataMigrationRecordAsync()).DataMigrations
.ToDictionary(r => r.DataMigrationClass);
var outOfDateMigrations = _dataMigrations.Where(dataMigration =>
{
Records.DataMigration record;
if (currentVersions.TryGetValue(dataMigration.GetType().FullName, out record) && record.Version.HasValue)
{
return CreateUpgradeLookupTable(dataMigration).ContainsKey(record.Version.Value);
}
return GetMethod(dataMigration, "Create") != null;
});
return outOfDateMigrations.Select(m => _typeFeatureProvider.GetFeatureForDependency(m.GetType()).Id).ToArray();
}
public async Task Uninstall(string feature)
{
_logger.LogInformation("Uninstalling feature '{FeatureName}'.", feature);
var migrations = GetDataMigrations(feature);
// apply update methods to each migration | DataMigrationManager |
csharp | ServiceStack__ServiceStack | ServiceStack.Text/tests/ServiceStack.Text.Tests/JsonTests/JsonEnnumerableTests.cs | {
"start": 240,
"end": 619
} | public class ____
{
public ReadOnlyCollection<string> Results { get; set; }
}
[Test]
public void Does_deserialize_Empty_ReadOnlyCollection()
{
var dto = "{\"Results\":[]}".FromJson<ModelWithReadOnlyCollection>();
Assert.That(dto.Results.Count, Is.EqualTo(0));
}
| ModelWithReadOnlyCollection |
csharp | reactiveui__Akavache | src/Akavache.Benchmarks.V10/Utility.cs | {
"start": 468,
"end": 2728
} | internal static class ____
{
/// <summary>
/// Deletes a directory.
/// </summary>
/// <param name="directoryPath">The path to delete.</param>
public static void DeleteDirectory(string directoryPath)
{
// From https://stackoverflow.com/questions/329355/cannot-delete-directory-with-directory-deletepath-true/329502#329502
try
{
var di = new DirectoryInfo(directoryPath);
var files = di.EnumerateFiles();
var dirs = di.EnumerateDirectories();
foreach (var file in files)
{
File.SetAttributes(file.FullName, FileAttributes.Normal);
new Action(() => file.Delete()).Retry();
}
foreach (var dir in dirs)
{
DeleteDirectory(dir.FullName);
}
File.SetAttributes(directoryPath, FileAttributes.Normal);
Directory.Delete(directoryPath, false);
}
catch (Exception ex)
{
Console.Error.WriteLine("***** Failed to clean up!! *****");
Console.Error.WriteLine(ex);
}
}
public static IDisposable WithEmptyDirectory(out string directoryPath)
{
var di = new DirectoryInfo(Path.Combine(".", Guid.NewGuid().ToString()));
if (di.Exists)
{
DeleteDirectory(di.FullName);
}
di.Create();
directoryPath = di.FullName;
return Disposable.Create(() =>
{
DeleteDirectory(di.FullName);
});
}
public static void Retry(this Action block, int retries = 2)
{
while (true)
{
try
{
block();
return;
}
catch (Exception)
{
if (retries == 0)
{
throw;
}
retries--;
Thread.Sleep(10);
}
}
}
}
}
| Utility |
csharp | dotnet__aspnetcore | src/Middleware/WebSockets/test/ConformanceTests/Autobahn/AutobahnSpec.cs | {
"start": 260,
"end": 1787
} | public class ____
{
public string OutputDirectory { get; }
public IList<ServerSpec> Servers { get; } = new List<ServerSpec>();
public IList<string> Cases { get; } = new List<string>();
public IList<string> ExcludedCases { get; } = new List<string>();
public AutobahnSpec(string outputDirectory)
{
OutputDirectory = outputDirectory;
}
public AutobahnSpec WithServer(string name, string url)
{
Servers.Add(new ServerSpec(name, url));
return this;
}
public AutobahnSpec IncludeCase(params string[] caseSpecs)
{
foreach (var caseSpec in caseSpecs)
{
Cases.Add(caseSpec);
}
return this;
}
public AutobahnSpec ExcludeCase(params string[] caseSpecs)
{
foreach (var caseSpec in caseSpecs)
{
ExcludedCases.Add(caseSpec);
}
return this;
}
public void WriteJson(string file)
{
File.WriteAllText(file, GetJson().ToString(Formatting.Indented));
}
public JObject GetJson() => new JObject(
new JProperty("options", new JObject(
new JProperty("failByDrop", false))),
new JProperty("outdir", OutputDirectory),
new JProperty("servers", new JArray(Servers.Select(s => s.GetJson()).ToArray())),
new JProperty("cases", new JArray(Cases.ToArray())),
new JProperty("exclude-cases", new JArray(ExcludedCases.ToArray())),
new JProperty("exclude-agent-cases", new JObject()));
}
| AutobahnSpec |
csharp | AvaloniaUI__Avalonia | src/Avalonia.Base/Media/IImmutableGlyphRunReference.cs | {
"start": 209,
"end": 550
} | internal class ____ : IImmutableGlyphRunReference
{
public ImmutableGlyphRunReference(IRef<IGlyphRunImpl>? glyphRun)
{
GlyphRun = glyphRun;
}
public IRef<IGlyphRunImpl>? GlyphRun { get; private set; }
public void Dispose()
{
GlyphRun?.Dispose();
GlyphRun = null;
}
} | ImmutableGlyphRunReference |
csharp | ServiceStack__ServiceStack | ServiceStack.Aws/tests/ServiceStack.Aws.Tests/Sqs/SqsMqBufferTestsDrain.cs | {
"start": 251,
"end": 5253
} | public class ____
{
private SqsQueueManager sqsQueueManager;
private SqsMqBufferFactory sqsMqBufferFactory;
[OneTimeSetUp]
public void FixtureSetup()
{
sqsQueueManager = new SqsQueueManager(SqsTestClientFactory.GetConnectionFactory());
sqsMqBufferFactory = new SqsMqBufferFactory(SqsTestClientFactory.GetConnectionFactory());
}
[OneTimeTearDown]
public void FixtureTeardown()
{
if (SqsTestAssert.IsFakeClient)
return;
// Cleanup anything left cached that we tested with
var queueNamesToDelete = new List<string>(sqsQueueManager.QueueNameMap.Keys);
foreach (var queueName in queueNamesToDelete)
{
try
{
sqsQueueManager.DeleteQueue(queueName);
}
catch { }
}
}
private ISqsMqBuffer GetNewMqBuffer(int? visibilityTimeoutSeconds = null,
int? receiveWaitTimeSeconds = null,
bool? disableBuffering = null)
{
var qd = sqsQueueManager.CreateQueue(GetNewId(), visibilityTimeoutSeconds, receiveWaitTimeSeconds, disableBuffering);
var buffer = sqsMqBufferFactory.GetOrCreate(qd);
return buffer;
}
private string GetNewId() => Guid.NewGuid().ToString("N");
[Test]
public void Buffers_are_drained_on_timer_even_if_not_full()
{
using var buffer = GetNewMqBuffer();
2.Times(i => buffer.Send(new SendMessageRequest
{
QueueUrl = buffer.QueueDefinition.QueueUrl,
MessageBody = GetNewId()
}));
4.Times(i => buffer.Delete(new DeleteMessageRequest
{
QueueUrl = buffer.QueueDefinition.QueueUrl,
ReceiptHandle = GetNewId()
}));
3.Times(i => buffer.ChangeVisibility(new ChangeMessageVisibilityRequest
{
QueueUrl = buffer.QueueDefinition.QueueUrl,
ReceiptHandle = GetNewId()
}));
using var buffer2 = GetNewMqBuffer();
3.Times(i => buffer2.Send(new SendMessageRequest
{
QueueUrl = buffer2.QueueDefinition.QueueUrl,
MessageBody = GetNewId()
}));
2.Times(i => buffer2.Delete(new DeleteMessageRequest
{
QueueUrl = buffer2.QueueDefinition.QueueUrl,
ReceiptHandle = GetNewId()
}));
4.Times(i => buffer2.ChangeVisibility(new ChangeMessageVisibilityRequest
{
QueueUrl = buffer2.QueueDefinition.QueueUrl,
ReceiptHandle = GetNewId()
}));
using var buffer3 = GetNewMqBuffer();
4.Times(i => buffer3.Send(new SendMessageRequest
{
QueueUrl = buffer3.QueueDefinition.QueueUrl,
MessageBody = GetNewId()
}));
3.Times(i => buffer3.Delete(new DeleteMessageRequest
{
QueueUrl = buffer3.QueueDefinition.QueueUrl,
ReceiptHandle = GetNewId()
}));
2.Times(i => buffer3.ChangeVisibility(new ChangeMessageVisibilityRequest
{
QueueUrl = buffer3.QueueDefinition.QueueUrl,
ReceiptHandle = GetNewId()
}));
// Should all have something buffered
Assert.Greater(buffer.SendBufferCount, 0, "1 SendBufferCount");
Assert.Greater(buffer.DeleteBufferCount, 0, "1 DeleteBufferCount");
Assert.Greater(buffer.ChangeVisibilityBufferCount, 0, "1 CvBufferCount");
Assert.Greater(buffer2.SendBufferCount, 0, "2 SendBufferCount");
Assert.Greater(buffer2.DeleteBufferCount, 0, "2 DeleteBufferCount");
Assert.Greater(buffer2.ChangeVisibilityBufferCount, 0, "2 CvBufferCount");
Assert.Greater(buffer3.SendBufferCount, 0, "3 SendBufferCount");
Assert.Greater(buffer3.DeleteBufferCount, 0, "3 DeleteBufferCount");
Assert.Greater(buffer3.ChangeVisibilityBufferCount, 0, "3 CvBufferCount");
// Set the buffer flush on the factory. Setting it back to zero will still have the timer fire
// at least once, and then it will be cleared after the first fire.
sqsMqBufferFactory.BufferFlushIntervalSeconds = 1;
sqsMqBufferFactory.BufferFlushIntervalSeconds = 0;
Thread.Sleep(2000);
// Should all be drained
Assert.AreEqual(0, buffer.SendBufferCount, "1 SendBufferCount");
Assert.AreEqual(0, buffer.DeleteBufferCount, "1 DeleteBufferCount");
Assert.AreEqual(0, buffer.ChangeVisibilityBufferCount, "1 CvBufferCount");
Assert.AreEqual(0, buffer2.SendBufferCount, "2 SendBufferCount");
Assert.AreEqual(0, buffer2.DeleteBufferCount, "2 DeleteBufferCount");
Assert.AreEqual(0, buffer2.ChangeVisibilityBufferCount, "2 CvBufferCount");
Assert.AreEqual(0, buffer3.SendBufferCount, "3 SendBufferCount");
Assert.AreEqual(0, buffer3.DeleteBufferCount, "3 DeleteBufferCount");
Assert.AreEqual(0, buffer3.ChangeVisibilityBufferCount, "3 CvBufferCount");
}
} | SqsMqBufferTestsDrain |
csharp | dotnet__machinelearning | src/Microsoft.ML.Data/EntryPoints/SummarizePredictor.cs | {
"start": 816,
"end": 3926
} | public sealed class ____ : InputBase
{
}
[TlcModule.EntryPoint(Name = "Models.Summarizer", Desc = "Summarize a linear regression predictor.")]
public static CommonOutputs.SummaryOutput Summarize(IHostEnvironment env, SummarizePredictor.Input input)
{
Contracts.CheckValue(env, nameof(env));
var host = env.Register("LinearRegressionPredictor");
host.CheckValue(input, nameof(input));
EntryPointUtils.CheckInputArgs(host, input);
RoleMappedData rmd;
IPredictor predictor;
input.PredictorModel.PrepareData(host, new EmptyDataView(host, input.PredictorModel.TransformModel.InputSchema), out rmd, out predictor);
var output = new CommonOutputs.SummaryOutput();
output.Summary = GetSummaryAndStats(host, predictor, rmd.Schema, out output.Stats);
return output;
}
[BestFriend]
internal static IDataView GetSummaryAndStats(IHostEnvironment env, IPredictor predictor, RoleMappedSchema schema, out IDataView stats)
{
var calibrated = predictor as IWeaklyTypedCalibratedModelParameters;
while (calibrated != null)
{
predictor = calibrated.WeaklyTypedSubModel;
calibrated = predictor as IWeaklyTypedCalibratedModelParameters;
}
IDataView summary = null;
stats = null;
var dvGetter = predictor as ICanGetSummaryAsIDataView;
var rowGetter = predictor as ICanGetSummaryAsIRow;
if (dvGetter != null)
summary = dvGetter.GetSummaryDataView(schema);
if (rowGetter != null)
{
var row = rowGetter.GetSummaryIRowOrNull(schema);
env.Check(dvGetter == null || row == null,
"Predictor outputs two summary data views, don't know which one to choose");
if (row != null)
summary = RowCursorUtils.RowAsDataView(env, row);
var statsRow = rowGetter.GetStatsIRowOrNull(schema);
if (statsRow != null)
stats = RowCursorUtils.RowAsDataView(env, statsRow);
}
if (dvGetter == null && rowGetter == null)
{
var bldr = new ArrayDataViewBuilder(env);
var summaryModel = predictor as ICanSaveSummary;
// Save a data view containing one row and one column with the model summary.
if (summaryModel != null)
{
var sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
summaryModel.SaveSummary(sw, schema);
bldr.AddColumn("Summary", sb.ToString());
}
else
bldr.AddColumn("PredictorName", predictor.GetType().ToString());
summary = bldr.GetDataView();
}
env.AssertValue(summary);
return summary;
}
}
}
| Input |
csharp | ChilliCream__graphql-platform | src/StrawberryShake/CodeGeneration/test/CodeGeneration.Tests/Mappers/TestDataHelper.cs | {
"start": 425,
"end": 1738
} | public static class ____
{
public static ClientModel CreateClientModelAsync(
string queryResource,
string schemaResource)
{
var schema = SchemaHelper.Load(
[
new(Utf8GraphQLParser.Parse(Open(schemaResource))),
new(Utf8GraphQLParser.Parse("extend schema @key(fields: \"id\")"))
]);
var document = Utf8GraphQLParser.Parse(Open(queryResource));
return DocumentAnalyzer
.New()
.SetSchema(schema)
.AddDocument(document)
.Analyze();
}
public static async Task<ClientModel> CreateClientModelAsync([StringSyntax("graphql")] string query)
{
var schema =
await new ServiceCollection()
.AddStarWarsRepositories()
.AddGraphQL()
.AddStarWars()
.BuildSchemaAsync();
schema = SchemaHelper.Load(
[
new(schema.ToSyntaxNode()),
new(Utf8GraphQLParser.Parse("extend schema @key(fields: \"id\")"))
]);
var document = Utf8GraphQLParser.Parse(query);
return DocumentAnalyzer
.New()
.SetSchema(schema)
.AddDocument(document)
.Analyze();
}
}
| TestDataHelper |
csharp | dotnet__orleans | src/Orleans.Streaming/QueueBalancer/IResourceSelector.cs | {
"start": 230,
"end": 772
} | internal interface ____<T>
{
/// <summary>
/// Number of resources
/// </summary>
int Count { get; }
/// <summary>
/// Try to select certain count of resources from resource list, which doesn't overlap with existing selection
/// </summary>
/// <param name="newSelectionCount"></param>
/// <param name="existingSelection"></param>
/// <returns></returns>
List<T> NextSelection(int newSelectionCount, List<T> existingSelection);
}
}
| IResourceSelector |
csharp | dotnet__orleans | src/Orleans.Streaming/Common/SimpleCache/SimpleQueueCacheOptions.cs | {
"start": 171,
"end": 683
} | public class ____
{
/// <summary>
/// Gets or sets the size of the cache.
/// </summary>
/// <value>The size of the cache.</value>
public int CacheSize { get; set; } = DEFAULT_CACHE_SIZE;
/// <summary>
/// The default value of <see cref="CacheSize"/>.
/// </summary>
public const int DEFAULT_CACHE_SIZE = 4096;
}
/// <summary>
/// Validates <see cref="SimpleQueueCacheOptions"/>.
/// </summary>
| SimpleQueueCacheOptions |
csharp | dotnet__aspnetcore | src/Mvc/test/WebSites/RazorWebSite/Components/ComponentWithRelativePath.cs | {
"start": 207,
"end": 418
} | public class ____ : ViewComponent
{
public IViewComponentResult Invoke(Person person)
{
return View("../Shared/Components/ComponentWithRelativePath.cshtml", person);
}
}
| ComponentWithRelativePath |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Data/test/Data.Filters.Tests/FilterInputTypeTest.cs | {
"start": 15606,
"end": 15855
} | public class ____
: FilterInputType<IgnoreTest>
{
protected override void Configure(IFilterInputTypeDescriptor<IgnoreTest> descriptor)
{
descriptor.Ignore(x => x.Id);
}
}
| IgnoreTestFilterInputType |
csharp | atata-framework__atata | test/Atata.UnitTests/DataProvision/ObjectVerificationProviderExtensionMethodTests.cs | {
"start": 11250,
"end": 11835
} | public class ____ : ExtensionMethodTestSuite<int[], EndWithAny_IEnumerable>
{
static EndWithAny_IEnumerable() =>
For([1, 2, 3, 5])
.ThrowsArgumentNullException(should => should.EndWithAny((null as IEnumerable<int>)!))
.ThrowsArgumentException(should => should.EndWithAny())
.Pass(should => should.EndWithAny(5))
.Pass(should => should.EndWithAny(8, 5, 9))
.Fail(should => should.EndWithAny(2, 3))
.Fail(should => should.EndWithAny(9));
}
| EndWithAny_IEnumerable |
csharp | dotnet__maui | src/Controls/src/Core/SafeAreaElement.cs | {
"start": 153,
"end": 3383
} | internal static class ____
{
/// <summary>
/// The backing store for the <see cref="ISafeAreaElement.SafeAreaEdges" /> bindable property.
/// </summary>
public static readonly BindableProperty SafeAreaEdgesProperty =
BindableProperty.Create(nameof(ISafeAreaElement.SafeAreaEdges), typeof(SafeAreaEdges), typeof(ISafeAreaElement), SafeAreaEdges.Default,
defaultValueCreator: SafeAreaEdgesDefaultValueCreator);
static object SafeAreaEdgesDefaultValueCreator(BindableObject bindable)
=> ((ISafeAreaElement)bindable).SafeAreaEdgesDefaultValueCreator();
/// <summary>
/// Gets the effective safe area behavior for a specific edge.
/// </summary>
/// <param name="bindable">The bindable object to get the safe area behavior from.</param>
/// <param name="edge">The edge to get the behavior for (0=Left, 1=Top, 2=Right, 3=Bottom).</param>
/// <returns>The <see cref="SafeAreaRegions"/> for the specified edge.</returns>
internal static SafeAreaRegions GetEdgeValue(BindableObject bindable, int edge)
{
var edges = (SafeAreaEdges)bindable.GetValue(SafeAreaEdgesProperty);
return edges.GetEdge(edge);
}
/// <summary>
/// Gets the effective safe area behavior for a specific edge for elements that implement ISafeAreaView.
/// This method handles the logic for checking the new SafeAreaEdges property and falling back to legacy behavior.
/// </summary>
/// <param name="bindable">The bindable object that implements ISafeAreaView.</param>
/// <param name="edge">The edge to get the behavior for (0=Left, 1=Top, 2=Right, 3=Bottom).</param>
/// <returns>True if safe area should be obeyed for this edge, false otherwise.</returns>
internal static bool ShouldObeySafeAreaForEdge(BindableObject bindable, int edge)
{
// Check the SafeAreaEdges property
var regionForEdge = GetEdgeValue(bindable, edge);
// Handle the new SafeAreaRegions behavior (now obey-based instead of ignore-based)
if (regionForEdge == SafeAreaRegions.All)
{
return true; // Obey all safe area insets - content positioned only in safe area
}
if (regionForEdge == SafeAreaRegions.Container)
{
// Content flows under keyboard but stays out of top and bottom bars and notch
// For now, treat this as obeying safe area (can be enhanced later for keyboard-specific behavior)
return true;
}
if (regionForEdge == SafeAreaRegions.SoftInput)
{
// Always pad so content doesn't go under the keyboard
// For now, treat this as obeying safe area
return true;
}
if (regionForEdge == SafeAreaRegions.Default)
{
// Default behavior - apply platform safe area insets
return true;
}
if (regionForEdge == SafeAreaRegions.None)
{
// Content goes edge to edge with no safe area padding
return false;
}
// Fall back to legacy behavior if available (but invert the logic since we now return "should obey")
if (bindable is ISafeAreaView legacySafeAreaView)
{
return !legacySafeAreaView.IgnoreSafeArea; // Invert: if legacy says "ignore", we say "don't obey"
}
// Default to false (don't obey safe area) since the new default is SafeAreaRegions.None (edge to edge)
return false;
}
}
} | SafeAreaElement |
csharp | dotnetcore__Util | test/Util.Data.Sql.Tests/Builders/Clauses/SelectClauseTest.cs | {
"start": 201,
"end": 7487
} | public class ____ {
#region 测试初始化
/// <summary>
/// Select子句
/// </summary>
private readonly SelectClause _clause;
/// <summary>
/// 测试初始化
/// </summary>
public SelectClauseTest() {
_clause = new SelectClause( new TestSqlBuilder() );
}
/// <summary>
/// 获取Sql语句
/// </summary>
private string GetSql( ISelectClause clause = null ) {
clause ??= _clause;
var builder = new StringBuilder();
clause.AppendTo( builder );
return builder.ToString();
}
#endregion
#region 默认输出
/// <summary>
/// 默认输出
/// </summary>
[Fact]
public void TestDefault() {
Assert.Empty( GetSql() );
}
#endregion
#region Select
/// <summary>
/// 测试设置列名为*
/// </summary>
[Fact]
public void TestSelect_1() {
_clause.Select();
Assert.Equal( "Select *", GetSql() );
}
/// <summary>
/// 测试设置列名为*
/// </summary>
[Fact]
public void TestSelect_2() {
_clause.Select( "*" );
Assert.Equal( "Select *", GetSql() );
}
/// <summary>
/// 测试设置1个简单列
/// </summary>
[Fact]
public void TestSelect_3() {
_clause.Select( "a" );
Assert.Equal( "Select [a]", GetSql() );
}
/// <summary>
/// 测试设置2个简单列
/// </summary>
[Fact]
public void TestSelect_4() {
_clause.Select( "a,b" );
Assert.Equal( "Select [a],[b]", GetSql() );
}
/// <summary>
/// 测试设置1个带表别名的列
/// </summary>
[Fact]
public void TestSelect_5() {
_clause.Select( "a.b" );
Assert.Equal( "Select [a].[b]", GetSql() );
}
/// <summary>
/// 测试设置1个带表别名和列别名的列
/// </summary>
[Fact]
public void TestSelect_6() {
_clause.Select( "a.b as c" );
Assert.Equal( "Select [a].[b] As [c]", GetSql() );
}
/// <summary>
/// 测试设置2个带表别名和列别名的列
/// </summary>
[Fact]
public void TestSelect_7() {
_clause.Select( "a.b as c,[d].[e] [F]" );
Assert.Equal( "Select [a].[b] As [c],[d].[e] As [F]", GetSql() );
}
/// <summary>
/// 测试设置多个select
/// </summary>
[Fact]
public void TestSelect_8() {
_clause.Select( "a.b as c" );
_clause.Select( "[d].[e] [F]" );
Assert.Equal( "Select [a].[b] As [c],[d].[e] As [F]", GetSql() );
}
/// <summary>
/// 测试设置子查询列
/// </summary>
[Fact]
public void TestSelect_9() {
var result = new StringBuilder();
result.Append( "Select [a].[b]," );
result.AppendLine( "(Select [a] " );
result.Append( "From [b]) As [c]" );
var builder = new TestSqlBuilder().Select( "a" ).From( "b" );
_clause.Select( "a.b" );
_clause.Select( builder,"c" );
Assert.Equal( result.ToString(), GetSql() );
}
/// <summary>
/// 测试设置子查询列 - 内嵌表达式
/// </summary>
[Fact]
public void TestSelect_10() {
var result = new StringBuilder();
result.Append( "Select [a].[b]," );
result.AppendLine( "(Select [a] " );
result.Append( "From [b]) As [c]" );
_clause.Select( "a.b" );
_clause.Select( t => t.Select( "a" ).From( "b" ), "c" );
Assert.Equal( result.ToString(), GetSql() );
}
/// <summary>
/// 测试设置列 - 验证空值
/// </summary>
[Fact]
public void TestSelect_11() {
_clause.Select( "a" );
_clause.Select( "" );
Assert.Equal( "Select [a]", GetSql() );
}
#endregion
#region AppendSql
/// <summary>
/// 添加到select子句 - 替换[]为特定转义字符
/// </summary>
[Fact]
public void TestAppendSql_1() {
var clause = new SelectClause( new TestSqlBuilder( new TestDialect2(), new TestColumnCache( new TestDialect2() ) ) );
clause.AppendSql( "[a].[b], c.[D]", false );
Assert.Equal( "Select $a&.$b&, c.$D&", GetSql( clause ) );
}
/// <summary>
/// 添加到select子句 - 原样添加
/// </summary>
[Fact]
public void TestAppendSql_2() {
var clause = new SelectClause( new TestSqlBuilder( new TestDialect2(), new TestColumnCache( new TestDialect2() ) ) );
clause.AppendSql( "[a].[b], c.[D]", true );
Assert.Equal( "Select [a].[b], c.[D]", GetSql( clause ) );
}
/// <summary>
/// 添加到select子句 - 多次调用
/// </summary>
[Fact]
public void TestAppendSql_3() {
var clause = new SelectClause( new TestSqlBuilder( new TestDialect2(), new TestColumnCache( new TestDialect2() ) ) );
clause.AppendSql( "[a].[b],", true );
clause.AppendSql( "c.[D]", true );
Assert.Equal( "Select [a].[b],c.[D]", GetSql( clause ) );
}
/// <summary>
/// 测试添加到select子句 - 子查询
/// </summary>
[Fact]
public void TestAppendSql_4() {
var result = new StringBuilder();
result.Append( "Select [a].[b]," );
result.AppendLine( "(Select [a] " );
result.Append( "From [b]) As [c]" );
var builder = new TestSqlBuilder().Select( "a" ).From( "b" );
_clause.AppendSql( "[a].[b],",true );
_clause.AppendSql( "(", true );
_clause.AppendSql( builder );
_clause.AppendSql( ") As [c]", true );
Assert.Equal( result.ToString(), GetSql() );
}
/// <summary>
/// 测试添加到select子句 - 子查询 - 内嵌表达式
/// </summary>
[Fact]
public void TestAppendSql_5() {
var result = new StringBuilder();
result.Append( "Select [a].[b]," );
result.AppendLine( "(Select [a] " );
result.Append( "From [b]) As [c]" );
_clause.AppendSql( "[a].[b],", true );
_clause.AppendSql( "(", true );
_clause.AppendSql( t => t.Select( "a" ).From( "b" ) );
_clause.AppendSql( ") As [c]", true );
Assert.Equal( result.ToString(), GetSql() );
}
/// <summary>
/// 测试添加到select子句 - AppendSql末尾添加逗号,后跟Select
/// </summary>
[Fact]
public void TestAppendSql_6() {
var result = new StringBuilder();
result.Append( "Select [a].[b],c,[d]" );
_clause.Select( "a.b" );
_clause.AppendSql( ",c,", true );
_clause.Select( "d" );
Assert.Equal( result.ToString(), GetSql() );
}
/// <summary>
/// 添加到select子句 - 对[]转义
/// </summary>
[Fact]
public void TestAppendSql_7() {
var clause = new SelectClause( new TestSqlBuilder( new TestDialect2(), new TestColumnCache( new TestDialect2() ) ) );
clause.AppendSql( "[[a]].[b], c.[D]", false );
Assert.Equal( "Select [a].$b&, c.$D&", GetSql( clause ) );
}
#endregion
#region Clear
/// <summary>
/// 测试清理
/// </summary>
[Fact]
public void TestClear() {
_clause.Select( "a" );
_clause.Clear();
Assert.Empty( GetSql() );
}
#endregion
#region Clone
/// <summary>
/// 测试复制Select子句
/// </summary>
[Fact]
public void TestClone() {
//设置列
_clause.Select( "a" );
//复制并验证
var clone = _clause.Clone( new TestSqlBuilder() );
Assert.Equal( "Select [a]", GetSql( clone ) );
//修改原始子句,复制子句不应受影响
_clause.Select( "b" );
Assert.Equal( "Select [a]", GetSql( clone ) );
}
#endregion
} | SelectClauseTest |
csharp | unoplatform__uno | src/Uno.UI/UI/Xaml/Controls/NumberBox/NumberBox.mux.cs | {
"start": 698,
"end": 2958
} | partial class ____
{
private const string c_numberBoxHeaderName = "HeaderContentPresenter";
private const string c_numberBoxDownButtonName = "DownSpinButton";
private const string c_numberBoxUpButtonName = "UpSpinButton";
private const string c_numberBoxTextBoxName = "InputBox";
private const string c_numberBoxPopupName = "UpDownPopup";
private const string c_numberBoxPopupDownButtonName = "PopupDownSpinButton";
private const string c_numberBoxPopupUpButtonName = "PopupUpSpinButton";
private const string c_numberBoxPopupContentRootName = "PopupContentRoot";
private const double c_popupShadowDepth = 16.0;
private const string c_numberBoxPopupShadowDepthName = "NumberBoxPopupShadowDepth";
// Shockingly, there is no standard function for trimming strings.
private const string c_whitespace = " \n\r\t\f\v";
private static string trim(string s)
{
IEnumerable<(char c, int i)> GetNonWhiteSpace()
=> s.Select((c, i) => (c, i)).Where(p => !c_whitespace.Contains(p.c.ToString()));
var start = GetNonWhiteSpace().FirstOrDefault();
var end = GetNonWhiteSpace().LastOrDefault();
return (start.c == '\0' || end.c == '\0') ? "" : s.Substring(start.i, end.i - start.i + 1);
}
public NumberBox()
{
NumberFormatter = GetRegionalSettingsAwareDecimalFormatter();
PointerWheelChanged += OnNumberBoxScroll;
GotFocus += OnNumberBoxGotFocus;
LostFocus += OnNumberBoxLostFocus;
#if HAS_UNO // Uno specific.
Loaded += (s, e) => ReApplyTemplate();
Unloaded += (s, e) => DisposeRegistrations();
#endif
this.SetDefaultStyleKey();
SetDefaultInputScope();
// We are not revoking this since the event and the listener reside on the same object and as such have the same lifecycle.
// That means that as soon as the NumberBox gets removed so will the event and the listener.
RegisterPropertyChangedCallback(AutomationProperties.NameProperty, OnAutomationPropertiesNamePropertyChanged);
RegisterPropertyChangedCallback(AutomationProperties.LabeledByProperty, OnAutomationPropertiesLabeledByPropertyChanged);
}
private void UnhookEvents()
{
_eventSubscriptions.Disposable = null;
}
private void SetDefaultInputScope()
{
// Sets the default value of the InputScope property.
// Note that InputScope is a | NumberBox |
csharp | dotnetcore__WTM | src/WalkingTec.Mvvm.Core/Models/TopBasePoco.cs | {
"start": 327,
"end": 2820
} | public class ____
{
/// <summary>
/// Id
/// </summary>
[Key]
public Guid ID
{
get; set;
}
/// <summary>
/// 是否选中
/// 标识当前行数据是否被选中
/// </summary>
[NotMapped]
//[JsonConverter(typeof(InternalBoolConverter))]
//[JsonProperty("LAY_CHECKED")]
[JsonIgnore]
public bool Checked { get; set; }
/// <summary>
/// BatchError
/// </summary>
[NotMapped]
[JsonIgnore]
public string BatchError { get; set; }
/// <summary>
/// ExcelIndex
/// </summary>
[NotMapped]
[JsonIgnore]
public long ExcelIndex { get; set; }
public object GetID()
{
var idpro = this.GetType().GetSingleProperty("ID");
var id = idpro.GetValue(this);
return id;
}
public bool HasID()
{
bool rv = false;
var id = this.GetID();
switch (id)
{
case Guid g1 when g1 != Guid.Empty:
rv = true;
break;
case string s when string.IsNullOrEmpty(s) == false:
rv = true;
break;
case int i when i>0:
rv = true;
break;
case long l when l > 0:
rv = true;
break;
}
return rv;
}
public object GetParentID()
{
var idpro = this.GetType().GetSingleProperty("ParentId");
var id = idpro.GetValue(this) ?? "";
return id;
}
public Type GetIDType()
{
var idpro = this.GetType().GetSingleProperty("ID");
return idpro.PropertyType;
}
public void SetID(object id)
{
var idpro = this.GetType().GetSingleProperty("ID");
idpro.SetValue(this, id.ConvertValue(idpro.PropertyType));
}
private bool? _isBasePoco = null;
[NotMapped]
[JsonIgnore]
public bool IsBasePoco
{
get
{
if(_isBasePoco == null)
{
_isBasePoco = typeof(IBasePoco).IsAssignableFrom(this.GetType());
}
return _isBasePoco.Value;
}
}
}
}
| TopBasePoco |
csharp | GtkSharp__GtkSharp | Source/OldStuff/audit/mono-api-diff.cs | {
"start": 30845,
"end": 33822
} | class ____ : XMLNameGroup
{
Hashtable properties = new Hashtable ();
bool isTodo;
string comment;
protected override bool CheckIfAdd (string value, XmlNode node)
{
if (IsTODOAttribute (value)) {
isTodo = true;
XmlNode pNode = node.SelectSingleNode ("properties");
if (pNode != null && pNode.ChildNodes.Count > 0 && pNode.ChildNodes [0].Attributes ["value"] != null) {
comment = pNode.ChildNodes [0].Attributes ["value"].Value;
}
return false;
}
return !IsMeaninglessAttribute (value);
}
protected override void CompareToInner (string name, XmlNode node, XMLNameGroup other)
{
XMLAttributeProperties other_prop = ((XMLAttributes)other).properties [name] as XMLAttributeProperties;
XMLAttributeProperties this_prop = properties [name] as XMLAttributeProperties;
if (other_prop == null || this_prop == null)
return;
this_prop.CompareTo (document, node, other_prop);
counters.AddPartialToPartial (this_prop.Counters);
}
public override string GetNodeKey (string name, XmlNode node)
{
string key = null;
// if multiple attributes with the same name (type) exist, then we
// cannot be sure which attributes correspond, so we must use the
// name of the attribute (type) and the name/value of its properties
// as key
XmlNodeList attributes = node.ParentNode.SelectNodes("attribute[@name='" + name + "']");
if (attributes.Count > 1) {
ArrayList keyParts = new ArrayList ();
XmlNodeList properties = node.SelectNodes ("properties/property");
foreach (XmlNode property in properties) {
XmlAttributeCollection attrs = property.Attributes;
if (attrs["value"] != null) {
keyParts.Add (attrs["name"].Value + "=" + attrs["value"].Value);
} else {
keyParts.Add (attrs["name"].Value + "=");
}
}
// sort properties by name, as order of properties in XML is
// undefined
keyParts.Sort ();
// insert name (type) of attribute
keyParts.Insert (0, name);
StringBuilder sb = new StringBuilder ();
foreach (string value in keyParts) {
sb.Append (value);
sb.Append (';');
}
key = sb.ToString ();
} else {
key = name;
}
return key;
}
protected override void LoadExtraData(string name, XmlNode node)
{
XmlNode pNode = node.SelectSingleNode ("properties");
if (IsTODOAttribute (name)) {
isTodo = true;
if (pNode.ChildNodes [0].Attributes ["value"] != null) {
comment = pNode.ChildNodes [0].Attributes ["value"].Value;
}
return;
}
if (pNode != null) {
XMLAttributeProperties p = new XMLAttributeProperties (name);
p.LoadData (pNode);
properties[name] = p;
}
}
public override string GroupName {
get { return "attributes"; }
}
public override string Name {
get { return "attribute"; }
}
public bool IsTodo {
get { return isTodo; }
}
public string Comment {
get { return comment; }
}
}
| XMLAttributes |
csharp | dotnet__orleans | test/Extensions/TesterAzureUtils/Persistence/PersistenceStateTests_AzureTableGrainStorage.cs | {
"start": 363,
"end": 536
} | public class ____ : Base_PersistenceGrainTests_AzureStore, IClassFixture<PersistenceStateTests_AzureTableGrainStorage.Fixture>
{
| PersistenceStateTests_AzureTableGrainStorage |
csharp | SixLabors__ImageSharp | src/ImageSharp/Formats/Png/PngEncoder.cs | {
"start": 220,
"end": 2070
} | public class ____ : QuantizingAnimatedImageEncoder
{
/// <summary>
/// Gets the number of bits per sample or per palette index (not per pixel).
/// Not all values are allowed for all <see cref="ColorType" /> values.
/// </summary>
public PngBitDepth? BitDepth { get; init; }
/// <summary>
/// Gets the color type.
/// </summary>
public PngColorType? ColorType { get; init; }
/// <summary>
/// Gets the filter method.
/// </summary>
public PngFilterMethod? FilterMethod { get; init; }
/// <summary>
/// Gets the compression level 1-9.
/// <remarks>Defaults to <see cref="PngCompressionLevel.DefaultCompression" />.</remarks>
/// </summary>
public PngCompressionLevel CompressionLevel { get; init; } = PngCompressionLevel.DefaultCompression;
/// <summary>
/// Gets the threshold of characters in text metadata, when compression should be used.
/// </summary>
public int TextCompressionThreshold { get; init; } = 1024;
/// <summary>
/// Gets the gamma value, that will be written the image.
/// </summary>
/// <value>The gamma value of the image.</value>
public float? Gamma { get; init; }
/// <summary>
/// Gets a value indicating whether this instance should write an Adam7 interlaced image.
/// </summary>
public PngInterlaceMode? InterlaceMethod { get; init; }
/// <summary>
/// Gets the chunk filter method. This allows to filter ancillary chunks.
/// </summary>
public PngChunkFilter? ChunkFilter { get; init; }
/// <inheritdoc/>
protected override void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
{
using PngEncoderCore encoder = new(image.Configuration, this);
encoder.Encode(image, stream, cancellationToken);
}
}
| PngEncoder |
csharp | AvaloniaUI__Avalonia | src/tools/Avalonia.Generators/Common/Domain/IViewResolver.cs | {
"start": 251,
"end": 434
} | internal record ____(string ClassName, string Namespace)
{
public string FullName => $"{Namespace}.{ClassName}";
public override string ToString() => FullName;
}
| ResolvedViewInfo |
csharp | jbogard__MediatR | samples/MediatR.Examples/ExceptionHandler/Handlers.cs | {
"start": 794,
"end": 1155
} | public class ____ : IRequestHandler<PingResourceTimeout, Pong>
{
private readonly TextWriter _writer;
public PingResourceTimeoutHandler(TextWriter writer) => _writer = writer;
public Task<Pong> Handle(PingResourceTimeout request, CancellationToken cancellationToken)
{
throw new TaskCanceledException();
}
}
| PingResourceTimeoutHandler |
csharp | npgsql__npgsql | src/Npgsql/Replication/PgOutput/Messages/RollbackPreparedMessage.cs | {
"start": 172,
"end": 2022
} | public sealed class ____ : PreparedTransactionControlMessage
{
/// <summary>
/// Flags for the rollback prepared; currently unused.
/// </summary>
public RollbackPreparedFlags Flags { get; private set; }
/// <summary>
/// The end LSN of the prepared transaction.
/// </summary>
public NpgsqlLogSequenceNumber PreparedTransactionEndLsn => FirstLsn;
/// <summary>
/// The end LSN of the rollback prepared transaction.
/// </summary>
public NpgsqlLogSequenceNumber RollbackPreparedEndLsn => SecondLsn;
/// <summary>
/// Prepare timestamp of the transaction.
/// </summary>
public DateTime TransactionPrepareTimestamp => Timestamp;
/// <summary>
/// Rollback timestamp of the transaction.
/// </summary>
public DateTime TransactionRollbackTimestamp { get; private set; }
internal RollbackPreparedMessage() {}
internal RollbackPreparedMessage Populate(
NpgsqlLogSequenceNumber walStart, NpgsqlLogSequenceNumber walEnd, DateTime serverClock, RollbackPreparedFlags flags,
NpgsqlLogSequenceNumber preparedTransactionEndLsn, NpgsqlLogSequenceNumber rollbackPreparedEndLsn, DateTime transactionPrepareTimestamp, DateTime transactionRollbackTimestamp,
uint transactionXid, string transactionGid)
{
base.Populate(walStart, walEnd, serverClock,
firstLsn: preparedTransactionEndLsn,
secondLsn: rollbackPreparedEndLsn,
timestamp: transactionPrepareTimestamp,
transactionXid: transactionXid,
transactionGid: transactionGid);
Flags = flags;
TransactionRollbackTimestamp = transactionRollbackTimestamp;
return this;
}
/// <summary>
/// Flags for the rollback prepared; currently unused.
/// </summary>
[Flags]
| RollbackPreparedMessage |
csharp | abpframework__abp | modules/cms-kit/src/Volo.CmsKit.Admin.Application.Contracts/Volo/CmsKit/Admin/Blogs/UpdateBlogPostDto.cs | {
"start": 228,
"end": 998
} | public class ____ : ExtensibleObject, IHasConcurrencyStamp
{
[Required]
[DynamicMaxLength(typeof(BlogPostConsts), nameof(BlogPostConsts.MaxTitleLength))]
public string Title { get; set; }
[Required]
[DynamicStringLength(typeof(BlogPostConsts), nameof(BlogPostConsts.MaxSlugLength), nameof(BlogPostConsts.MinSlugLength))]
public string Slug { get; set; }
[DynamicMaxLength(typeof(BlogPostConsts), nameof(BlogPostConsts.MaxShortDescriptionLength))]
public string ShortDescription { get; set; }
[DynamicMaxLength(typeof(BlogPostConsts), nameof(BlogPostConsts.MaxContentLength))]
public string Content { get; set; }
public Guid? CoverImageMediaId { get; set; }
public string ConcurrencyStamp { get; set; }
}
| UpdateBlogPostDto |
csharp | duplicati__duplicati | Duplicati/Library/Utility/PermissionHelper.cs | {
"start": 5632,
"end": 6148
} | struct ____
{
/// <summary>
/// The locally unique identifier (LUID) for the privilege.
/// </summary>
public LUID Luid;
/// <summary>
/// The attributes for the privilege.
/// </summary>
public int Attributes;
}
/// <summary>
/// Structure that contains the privileges associated with a token.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
| LUID_AND_ATTRIBUTES |
csharp | dotnet__orleans | src/api/Orleans.Transactions.TestKit.Base/Orleans.Transactions.TestKit.Base.cs | {
"start": 9494,
"end": 10377
} | partial class ____ : TransactionTestRunnerBase
{
public GrainFaultTransactionTestRunner(IGrainFactory grainFactory, System.Action<string> output) : base(default!, default!) { }
public virtual System.Threading.Tasks.Task AbortTransactionExceptionInnerExceptionOnlyContainsOneRootCauseException(string grainStates) { throw null; }
public virtual System.Threading.Tasks.Task AbortTransactionOnExceptions(string grainStates) { throw null; }
public virtual System.Threading.Tasks.Task AbortTransactionOnOrphanCalls(string grainStates) { throw null; }
public virtual System.Threading.Tasks.Task AbortTransactionOnReadOnlyViolatedException(string grainStates) { throw null; }
public virtual System.Threading.Tasks.Task MultiGrainAbortTransactionOnExceptions(string grainStates) { throw null; }
}
| GrainFaultTransactionTestRunner |
csharp | unoplatform__uno | src/Uno.UI/Generated/3.0.0.0/Microsoft.UI.Xaml/AutomationTextAttributesEnum.cs | {
"start": 255,
"end": 6094
} | public enum ____
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
AnimationStyleAttribute = 40000,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
BackgroundColorAttribute = 40001,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
BulletStyleAttribute = 40002,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
CapStyleAttribute = 40003,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
CultureAttribute = 40004,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
FontNameAttribute = 40005,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
FontSizeAttribute = 40006,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
FontWeightAttribute = 40007,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
ForegroundColorAttribute = 40008,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
HorizontalTextAlignmentAttribute = 40009,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IndentationFirstLineAttribute = 40010,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IndentationLeadingAttribute = 40011,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IndentationTrailingAttribute = 40012,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IsHiddenAttribute = 40013,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IsItalicAttribute = 40014,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IsReadOnlyAttribute = 40015,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IsSubscriptAttribute = 40016,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IsSuperscriptAttribute = 40017,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
MarginBottomAttribute = 40018,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
MarginLeadingAttribute = 40019,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
MarginTopAttribute = 40020,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
MarginTrailingAttribute = 40021,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
OutlineStylesAttribute = 40022,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
OverlineColorAttribute = 40023,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
OverlineStyleAttribute = 40024,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
StrikethroughColorAttribute = 40025,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
StrikethroughStyleAttribute = 40026,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
TabsAttribute = 40027,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
TextFlowDirectionsAttribute = 40028,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
UnderlineColorAttribute = 40029,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
UnderlineStyleAttribute = 40030,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
AnnotationTypesAttribute = 40031,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
AnnotationObjectsAttribute = 40032,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
StyleNameAttribute = 40033,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
StyleIdAttribute = 40034,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
LinkAttribute = 40035,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
IsActiveAttribute = 40036,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
SelectionActiveEndAttribute = 40037,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
CaretPositionAttribute = 40038,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
CaretBidiModeAttribute = 40039,
#endif
}
#endif
}
| AutomationTextAttributesEnum |
csharp | LibreHardwareMonitor__LibreHardwareMonitor | LibreHardwareMonitorLib/Interop/NvApi.cs | {
"start": 22267,
"end": 22418
} | internal enum ____
{
CurrentFrequency,
BaseClock,
BoostClock,
ClockTypeNumber
}
| NvGpuClockFrequenciesClockType |
csharp | abpframework__abp | framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Conventions/AbpServiceConvention_Tests.cs | {
"start": 4491,
"end": 4585
} | public class ____ : BaseController
{
}
[ExposeServices(typeof(BaseController))]
| DerivedController |
csharp | dotnet__aspnetcore | src/Servers/Kestrel/test/InMemory.FunctionalTests/TlsListenerTests.cs | {
"start": 935,
"end": 4561
} | public class ____ : TestApplicationErrorLoggerLoggedTest
{
private static readonly X509Certificate2 _x509Certificate2 = TestResources.GetTestCertificate();
[Fact]
public async Task TlsClientHelloBytesCallback_InvokedAndHasTlsMessageBytes()
{
var tlsClientHelloCallbackInvoked = false;
var testContext = new TestServiceContext(LoggerFactory);
await using (var server = new TestServer(context => Task.CompletedTask,
testContext,
listenOptions =>
{
listenOptions.UseHttps(_x509Certificate2, httpsOptions =>
{
httpsOptions.TlsClientHelloBytesCallback = (connection, clientHelloBytes) =>
{
Logger.LogDebug("[Received TlsClientHelloBytesCallback] Connection: {0}; TLS client hello buffer: {1}", connection.ConnectionId, clientHelloBytes.Length);
tlsClientHelloCallbackInvoked = true;
Assert.True(clientHelloBytes.Length > 32);
Assert.NotNull(connection);
};
});
}))
{
using (var connection = server.CreateConnection())
{
using (var sslStream = new SslStream(connection.Stream, false, (sender, cert, chain, errors) => true, null))
{
await sslStream.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
{
TargetHost = "localhost",
EnabledSslProtocols = SslProtocols.None
}, CancellationToken.None);
var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n");
await sslStream.WriteAsync(request, 0, request.Length);
await sslStream.ReadAsync(new Memory<byte>(new byte[1024]));
}
}
}
Assert.True(tlsClientHelloCallbackInvoked);
}
[Fact]
public async Task TlsClientHelloBytesCallback_UsesOptionsTimeout()
{
var tlsClientHelloCallbackInvoked = false;
var testContext = new TestServiceContext(LoggerFactory);
await using (var server = new TestServer(context => Task.CompletedTask,
testContext,
listenOptions =>
{
listenOptions.UseHttps(_x509Certificate2, httpsOptions =>
{
httpsOptions.HandshakeTimeout = TimeSpan.FromMilliseconds(1);
httpsOptions.TlsClientHelloBytesCallback = (connection, clientHelloBytes) =>
{
Logger.LogDebug("[Received TlsClientHelloBytesCallback] Connection: {0}; TLS client hello buffer: {1}", connection.ConnectionId, clientHelloBytes.Length);
tlsClientHelloCallbackInvoked = true;
Assert.True(clientHelloBytes.Length > 32);
Assert.NotNull(connection);
};
});
}))
{
using (var connection = server.CreateConnection())
{
await connection.TransportConnection.Input.WriteAsync(new byte[] { 0x16 });
var readResult = await connection.TransportConnection.Output.ReadAsync();
// HttpsConnectionMiddleware catches the exception, so we can only check the effects of the timeout here
Assert.True(readResult.IsCompleted);
}
}
Assert.False(tlsClientHelloCallbackInvoked);
}
}
| TlsListenerTests |
csharp | dotnet__efcore | test/EFCore.Sqlite.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextModelBuilder.cs | {
"start": 484,
"end": 383891
} | public partial class ____
{
private DbContextModel()
: base(skipDetectChanges: false, modelId: new Guid("00000000-0000-0000-0000-000000000000"), entityTypeCount: 10)
{
}
partial void Initialize()
{
var autoIncrementEntity = AutoIncrementEntityEntityType.Create(this);
var data = DataEntityType.Create(this);
var dependentBase = DependentBaseEntityType.Create(this);
var manyTypes = ManyTypesEntityType.Create(this);
var principalBase = PrincipalBaseEntityType.Create(this);
var ownedType = OwnedTypeEntityType.Create(this);
var ownedType0 = OwnedType0EntityType.Create(this);
var principalBasePrincipalDerivedDependentBasebyte = PrincipalBasePrincipalDerivedDependentBasebyteEntityType.Create(this);
var dependentDerived = DependentDerivedEntityType.Create(this, dependentBase);
var principalDerived = PrincipalDerivedEntityType.Create(this, principalBase);
DependentBaseEntityType.CreateForeignKey1(dependentBase, principalBase);
DependentBaseEntityType.CreateForeignKey2(dependentBase, principalDerived);
OwnedTypeEntityType.CreateForeignKey1(ownedType, principalBase);
OwnedTypeEntityType.CreateForeignKey2(ownedType, ownedType);
OwnedType0EntityType.CreateForeignKey1(ownedType0, principalDerived);
PrincipalBasePrincipalDerivedDependentBasebyteEntityType.CreateForeignKey1(principalBasePrincipalDerivedDependentBasebyte, principalDerived);
PrincipalBasePrincipalDerivedDependentBasebyteEntityType.CreateForeignKey2(principalBasePrincipalDerivedDependentBasebyte, principalBase);
PrincipalDerivedEntityType.CreateForeignKey1(principalDerived, principalBase);
PrincipalBaseEntityType.CreateSkipNavigation1(principalBase, principalDerived, principalBasePrincipalDerivedDependentBasebyte);
PrincipalDerivedEntityType.CreateSkipNavigation1(principalDerived, principalBase, principalBasePrincipalDerivedDependentBasebyte);
AutoIncrementEntityEntityType.CreateAnnotations(autoIncrementEntity);
DataEntityType.CreateAnnotations(data);
DependentBaseEntityType.CreateAnnotations(dependentBase);
ManyTypesEntityType.CreateAnnotations(manyTypes);
PrincipalBaseEntityType.CreateAnnotations(principalBase);
OwnedTypeEntityType.CreateAnnotations(ownedType);
OwnedType0EntityType.CreateAnnotations(ownedType0);
PrincipalBasePrincipalDerivedDependentBasebyteEntityType.CreateAnnotations(principalBasePrincipalDerivedDependentBasebyte);
DependentDerivedEntityType.CreateAnnotations(dependentDerived);
PrincipalDerivedEntityType.CreateAnnotations(principalDerived);
AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel());
}
private IRelationalModel CreateRelationalModel()
{
var relationalModel = new RelationalModel(this);
var autoIncrementEntity = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelSqliteTest+AutoIncrementEntity")!;
var defaultTableMappings = new List<TableMappingBase<ColumnMappingBase>>();
autoIncrementEntity.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelSqliteTest+AutoIncrementEntity", null, relationalModel);
var idColumnBase = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase.Columns.Add("Id", idColumnBase);
var nameColumnBase = new ColumnBase<ColumnMappingBase>("Name", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase.Columns.Add("Name", nameColumnBase);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelSqliteTest+AutoIncrementEntity", microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityMappingBase = new TableMappingBase<ColumnMappingBase>(autoIncrementEntity, microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityMappingBase, false);
defaultTableMappings.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase, autoIncrementEntity.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nameColumnBase, autoIncrementEntity.FindProperty("Name")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelSqliteTestAutoIncrementEntityMappingBase);
var tableMappings = new List<TableMapping>();
autoIncrementEntity.SetRuntimeAnnotation("Relational:TableMappings", tableMappings);
var autoIncrementEntityTable = new Table("AutoIncrementEntity", null, relationalModel);
var idColumn = new Column("Id", "INTEGER", autoIncrementEntityTable);
autoIncrementEntityTable.Columns.Add("Id", idColumn);
idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(idColumn);
var nameColumn = new Column("Name", "TEXT", autoIncrementEntityTable)
{
IsNullable = true
};
autoIncrementEntityTable.Columns.Add("Name", nameColumn);
nameColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nameColumn);
relationalModel.Tables.Add(("AutoIncrementEntity", null), autoIncrementEntityTable);
var autoIncrementEntityTableMapping = new TableMapping(autoIncrementEntity, autoIncrementEntityTable, null);
autoIncrementEntityTable.AddTypeMapping(autoIncrementEntityTableMapping, false);
tableMappings.Add(autoIncrementEntityTableMapping);
RelationalModel.CreateColumnMapping(idColumn, autoIncrementEntity.FindProperty("Id")!, autoIncrementEntityTableMapping);
RelationalModel.CreateColumnMapping(nameColumn, autoIncrementEntity.FindProperty("Name")!, autoIncrementEntityTableMapping);
var pK_AutoIncrementEntity = new UniqueConstraint("PK_AutoIncrementEntity", autoIncrementEntityTable, new[] { idColumn });
autoIncrementEntityTable.PrimaryKey = pK_AutoIncrementEntity;
pK_AutoIncrementEntity.SetRowKeyValueFactory(new SimpleRowKeyValueFactory<int>(pK_AutoIncrementEntity));
var pK_AutoIncrementEntityKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelSqliteTest+AutoIncrementEntity",
new[] { "Id" });
pK_AutoIncrementEntity.MappedKeys.Add(pK_AutoIncrementEntityKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_AutoIncrementEntityKey).Add(pK_AutoIncrementEntity);
autoIncrementEntityTable.UniqueConstraints.Add("PK_AutoIncrementEntity", pK_AutoIncrementEntity);
var data = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data")!;
var defaultTableMappings0 = new List<TableMappingBase<ColumnMappingBase>>();
data.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings0);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", null, relationalModel);
var blobColumnBase = new ColumnBase<ColumnMappingBase>("Blob", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase.Columns.Add("Blob", blobColumnBase);
var idColumnBase0 = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase.Columns.Add("Id", idColumnBase0);
var pointColumnBase = new ColumnBase<ColumnMappingBase>("Point", "POINT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase.Columns.Add("Point", pointColumnBase);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataMappingBase = new TableMappingBase<ColumnMappingBase>(data, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataMappingBase, false);
defaultTableMappings0.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase0, data.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)blobColumnBase, data.FindProperty("Blob")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)pointColumnBase, data.FindProperty("Point")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDataMappingBase);
var tableMappings0 = new List<TableMapping>();
data.SetRuntimeAnnotation("Relational:TableMappings", tableMappings0);
var dataTable = new Table("Data", null, relationalModel);
var idColumn0 = new Column("Id", "INTEGER", dataTable);
dataTable.Columns.Add("Id", idColumn0);
idColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(idColumn0);
var blobColumn = new Column("Blob", "BLOB", dataTable)
{
IsNullable = true
};
dataTable.Columns.Add("Blob", blobColumn);
blobColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(blobColumn);
var pointColumn = new Column("Point", "POINT", dataTable)
{
IsNullable = true
};
dataTable.Columns.Add("Point", pointColumn);
pointColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Point>(pointColumn);
relationalModel.Tables.Add(("Data", null), dataTable);
var dataTableMapping = new TableMapping(data, dataTable, null);
dataTable.AddTypeMapping(dataTableMapping, false);
tableMappings0.Add(dataTableMapping);
RelationalModel.CreateColumnMapping(idColumn0, data.FindProperty("Id")!, dataTableMapping);
RelationalModel.CreateColumnMapping(blobColumn, data.FindProperty("Blob")!, dataTableMapping);
RelationalModel.CreateColumnMapping(pointColumn, data.FindProperty("Point")!, dataTableMapping);
var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn0 });
dataTable.PrimaryKey = pK_Data;
pK_Data.SetRowKeyValueFactory(new SimpleRowKeyValueFactory<int>(pK_Data));
var pK_DataKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data",
new[] { "Id" });
pK_Data.MappedKeys.Add(pK_DataKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_DataKey).Add(pK_Data);
dataTable.UniqueConstraints.Add("PK_Data", pK_Data);
var dependentBase = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>")!;
var defaultTableMappings1 = new List<TableMappingBase<ColumnMappingBase>>();
dependentBase.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings1);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>", null, relationalModel);
var dataColumnBase = new ColumnBase<ColumnMappingBase>("Data", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Data", dataColumnBase);
var enumDiscriminatorColumnBase = new ColumnBase<ColumnMappingBase>("EnumDiscriminator", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("EnumDiscriminator", enumDiscriminatorColumnBase);
var idColumnBase1 = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Id", idColumnBase1);
var moneyColumnBase = new ColumnBase<ColumnMappingBase>("Money", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Money", moneyColumnBase);
var principalAlternateIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalAlternateId", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("PrincipalAlternateId", principalAlternateIdColumnBase);
var principalIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalId", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("PrincipalId", principalIdColumnBase);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase = new TableMappingBase<ColumnMappingBase>(dependentBase, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase, true);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase, false);
defaultTableMappings1.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalAlternateIdColumnBase, dependentBase.FindProperty("PrincipalAlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalIdColumnBase, dependentBase.FindProperty("PrincipalId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumDiscriminatorColumnBase, dependentBase.FindProperty("EnumDiscriminator")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase1, dependentBase.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
var tableMappings1 = new List<TableMapping>();
dependentBase.SetRuntimeAnnotation("Relational:TableMappings", tableMappings1);
var dependentBasebyteTable = new Table("DependentBase<byte?>", null, relationalModel);
var principalIdColumn = new Column("PrincipalId", "INTEGER", dependentBasebyteTable);
dependentBasebyteTable.Columns.Add("PrincipalId", principalIdColumn);
principalIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(principalIdColumn);
var principalAlternateIdColumn = new Column("PrincipalAlternateId", "TEXT", dependentBasebyteTable);
dependentBasebyteTable.Columns.Add("PrincipalAlternateId", principalAlternateIdColumn);
principalAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(principalAlternateIdColumn);
var dataColumn = new Column("Data", "TEXT", dependentBasebyteTable)
{
IsNullable = true
};
dependentBasebyteTable.Columns.Add("Data", dataColumn);
dataColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(dataColumn);
var enumDiscriminatorColumn = new Column("EnumDiscriminator", "INTEGER", dependentBasebyteTable);
dependentBasebyteTable.Columns.Add("EnumDiscriminator", enumDiscriminatorColumn);
enumDiscriminatorColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(enumDiscriminatorColumn);
var idColumn1 = new Column("Id", "INTEGER", dependentBasebyteTable)
{
IsNullable = true
};
dependentBasebyteTable.Columns.Add("Id", idColumn1);
idColumn1.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(idColumn1);
var moneyColumn = new Column("Money", "TEXT", dependentBasebyteTable)
{
IsNullable = true
};
dependentBasebyteTable.Columns.Add("Money", moneyColumn);
moneyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<decimal>(moneyColumn);
relationalModel.Tables.Add(("DependentBase<byte?>", null), dependentBasebyteTable);
var dependentBasebyteTableMapping = new TableMapping(dependentBase, dependentBasebyteTable, true)
{
IsSharedTablePrincipal = true,
};
dependentBasebyteTable.AddTypeMapping(dependentBasebyteTableMapping, false);
tableMappings1.Add(dependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(principalAlternateIdColumn, dependentBase.FindProperty("PrincipalAlternateId")!, dependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(principalIdColumn, dependentBase.FindProperty("PrincipalId")!, dependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(enumDiscriminatorColumn, dependentBase.FindProperty("EnumDiscriminator")!, dependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(idColumn1, dependentBase.FindProperty("Id")!, dependentBasebyteTableMapping);
var dependentDerived = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived<byte?>")!;
var defaultTableMappings2 = new List<TableMappingBase<ColumnMappingBase>>();
dependentDerived.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings2);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0 = new TableMappingBase<ColumnMappingBase>(dependentDerived, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0, false);
defaultTableMappings2.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalAlternateIdColumnBase, dependentDerived.FindProperty("PrincipalAlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalIdColumnBase, dependentDerived.FindProperty("PrincipalId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dataColumnBase, dependentDerived.FindProperty("Data")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumDiscriminatorColumnBase, dependentDerived.FindProperty("EnumDiscriminator")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase1, dependentDerived.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)moneyColumnBase, dependentDerived.FindProperty("Money")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase0);
var tableMappings2 = new List<TableMapping>();
dependentDerived.SetRuntimeAnnotation("Relational:TableMappings", tableMappings2);
var dependentBasebyteTableMapping0 = new TableMapping(dependentDerived, dependentBasebyteTable, null)
{
IsSharedTablePrincipal = false,
};
dependentBasebyteTable.AddTypeMapping(dependentBasebyteTableMapping0, false);
tableMappings2.Add(dependentBasebyteTableMapping0);
RelationalModel.CreateColumnMapping(principalAlternateIdColumn, dependentDerived.FindProperty("PrincipalAlternateId")!, dependentBasebyteTableMapping0);
RelationalModel.CreateColumnMapping(principalIdColumn, dependentDerived.FindProperty("PrincipalId")!, dependentBasebyteTableMapping0);
RelationalModel.CreateColumnMapping(dataColumn, dependentDerived.FindProperty("Data")!, dependentBasebyteTableMapping0);
RelationalModel.CreateColumnMapping(enumDiscriminatorColumn, dependentDerived.FindProperty("EnumDiscriminator")!, dependentBasebyteTableMapping0);
RelationalModel.CreateColumnMapping(idColumn1, dependentDerived.FindProperty("Id")!, dependentBasebyteTableMapping0);
RelationalModel.CreateColumnMapping(moneyColumn, dependentDerived.FindProperty("Money")!, dependentBasebyteTableMapping0);
var pK_DependentBasebyte = new UniqueConstraint("PK_DependentBase<byte?>", dependentBasebyteTable, new[] { principalIdColumn, principalAlternateIdColumn });
dependentBasebyteTable.PrimaryKey = pK_DependentBasebyte;
pK_DependentBasebyte.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_DependentBasebyte));
var pK_DependentBasebyteKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>",
new[] { "PrincipalId", "PrincipalAlternateId" });
pK_DependentBasebyte.MappedKeys.Add(pK_DependentBasebyteKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_DependentBasebyteKey).Add(pK_DependentBasebyte);
dependentBasebyteTable.UniqueConstraints.Add("PK_DependentBase<byte?>", pK_DependentBasebyte);
var iX_DependentBasebyte_PrincipalId = new TableIndex(
"IX_DependentBase<byte?>_PrincipalId", dependentBasebyteTable, new[] { principalIdColumn }, true);
iX_DependentBasebyte_PrincipalId.SetRowIndexValueFactory(new SimpleRowIndexValueFactory<long>(iX_DependentBasebyte_PrincipalId));
var iX_DependentBasebyte_PrincipalIdIx = RelationalModel.GetIndex(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>",
new[] { "PrincipalId" });
iX_DependentBasebyte_PrincipalId.MappedIndexes.Add(iX_DependentBasebyte_PrincipalIdIx);
RelationalModel.GetOrCreateTableIndexes(iX_DependentBasebyte_PrincipalIdIx).Add(iX_DependentBasebyte_PrincipalId);
dependentBasebyteTable.Indexes.Add("IX_DependentBase<byte?>_PrincipalId", iX_DependentBasebyte_PrincipalId);
var manyTypes = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes")!;
var defaultTableMappings3 = new List<TableMappingBase<ColumnMappingBase>>();
manyTypes.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings3);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes", null, relationalModel);
var boolColumnBase = new ColumnBase<ColumnMappingBase>("Bool", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Bool", boolColumnBase);
var boolArrayColumnBase = new ColumnBase<ColumnMappingBase>("BoolArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BoolArray", boolArrayColumnBase);
var boolReadOnlyCollectionColumnBase = new ColumnBase<ColumnMappingBase>("BoolReadOnlyCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BoolReadOnlyCollection", boolReadOnlyCollectionColumnBase);
var boolToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("BoolToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BoolToStringConverterProperty", boolToStringConverterPropertyColumnBase);
var boolToTwoValuesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("BoolToTwoValuesConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BoolToTwoValuesConverterProperty", boolToTwoValuesConverterPropertyColumnBase);
var boolToZeroOneConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("BoolToZeroOneConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BoolToZeroOneConverterProperty", boolToZeroOneConverterPropertyColumnBase);
var bytesColumnBase = new ColumnBase<ColumnMappingBase>("Bytes", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Bytes", bytesColumnBase);
var bytesArrayColumnBase = new ColumnBase<ColumnMappingBase>("BytesArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BytesArray", bytesArrayColumnBase);
var bytesToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("BytesToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("BytesToStringConverterProperty", bytesToStringConverterPropertyColumnBase);
var castingConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("CastingConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("CastingConverterProperty", castingConverterPropertyColumnBase);
var charColumnBase = new ColumnBase<ColumnMappingBase>("Char", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Char", charColumnBase);
var charArrayColumnBase = new ColumnBase<ColumnMappingBase>("CharArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("CharArray", charArrayColumnBase);
var charToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("CharToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("CharToStringConverterProperty", charToStringConverterPropertyColumnBase);
var dateOnlyColumnBase = new ColumnBase<ColumnMappingBase>("DateOnly", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateOnly", dateOnlyColumnBase);
var dateOnlyArrayColumnBase = new ColumnBase<ColumnMappingBase>("DateOnlyArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateOnlyArray", dateOnlyArrayColumnBase);
var dateOnlyToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateOnlyToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateOnlyToStringConverterProperty", dateOnlyToStringConverterPropertyColumnBase);
var dateTimeColumnBase = new ColumnBase<ColumnMappingBase>("DateTime", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTime", dateTimeColumnBase);
var dateTimeArrayColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeArray", dateTimeArrayColumnBase);
var dateTimeOffsetToBinaryConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeOffsetToBinaryConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeOffsetToBinaryConverterProperty", dateTimeOffsetToBinaryConverterPropertyColumnBase);
var dateTimeOffsetToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeOffsetToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeOffsetToBytesConverterProperty", dateTimeOffsetToBytesConverterPropertyColumnBase);
var dateTimeOffsetToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeOffsetToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeOffsetToStringConverterProperty", dateTimeOffsetToStringConverterPropertyColumnBase);
var dateTimeToBinaryConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeToBinaryConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeToBinaryConverterProperty", dateTimeToBinaryConverterPropertyColumnBase);
var dateTimeToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeToStringConverterProperty", dateTimeToStringConverterPropertyColumnBase);
var dateTimeToTicksConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DateTimeToTicksConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DateTimeToTicksConverterProperty", dateTimeToTicksConverterPropertyColumnBase);
var decimalColumnBase = new ColumnBase<ColumnMappingBase>("Decimal", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Decimal", decimalColumnBase);
var decimalArrayColumnBase = new ColumnBase<ColumnMappingBase>("DecimalArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DecimalArray", decimalArrayColumnBase);
var decimalNumberToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DecimalNumberToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DecimalNumberToBytesConverterProperty", decimalNumberToBytesConverterPropertyColumnBase);
var decimalNumberToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DecimalNumberToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DecimalNumberToStringConverterProperty", decimalNumberToStringConverterPropertyColumnBase);
var doubleColumnBase = new ColumnBase<ColumnMappingBase>("Double", "REAL", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Double", doubleColumnBase);
var doubleArrayColumnBase = new ColumnBase<ColumnMappingBase>("DoubleArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DoubleArray", doubleArrayColumnBase);
var doubleNumberToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DoubleNumberToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DoubleNumberToBytesConverterProperty", doubleNumberToBytesConverterPropertyColumnBase);
var doubleNumberToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("DoubleNumberToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("DoubleNumberToStringConverterProperty", doubleNumberToStringConverterPropertyColumnBase);
var enum16ColumnBase = new ColumnBase<ColumnMappingBase>("Enum16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum16", enum16ColumnBase);
var enum16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum16Array", enum16ArrayColumnBase);
var enum16AsStringColumnBase = new ColumnBase<ColumnMappingBase>("Enum16AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum16AsString", enum16AsStringColumnBase);
var enum16AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum16AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum16AsStringArray", enum16AsStringArrayColumnBase);
var enum16AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum16AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum16AsStringCollection", enum16AsStringCollectionColumnBase);
var enum16CollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum16Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum16Collection", enum16CollectionColumnBase);
var enum32ColumnBase = new ColumnBase<ColumnMappingBase>("Enum32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum32", enum32ColumnBase);
var enum32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum32Array", enum32ArrayColumnBase);
var enum32AsStringColumnBase = new ColumnBase<ColumnMappingBase>("Enum32AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum32AsString", enum32AsStringColumnBase);
var enum32AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum32AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum32AsStringArray", enum32AsStringArrayColumnBase);
var enum32AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum32AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum32AsStringCollection", enum32AsStringCollectionColumnBase);
var enum32CollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum32Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum32Collection", enum32CollectionColumnBase);
var enum64ColumnBase = new ColumnBase<ColumnMappingBase>("Enum64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum64", enum64ColumnBase);
var enum64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum64Array", enum64ArrayColumnBase);
var enum64AsStringColumnBase = new ColumnBase<ColumnMappingBase>("Enum64AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum64AsString", enum64AsStringColumnBase);
var enum64AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum64AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum64AsStringArray", enum64AsStringArrayColumnBase);
var enum64AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum64AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum64AsStringCollection", enum64AsStringCollectionColumnBase);
var enum64CollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum64Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum64Collection", enum64CollectionColumnBase);
var enum8ColumnBase = new ColumnBase<ColumnMappingBase>("Enum8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum8", enum8ColumnBase);
var enum8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum8Array", enum8ArrayColumnBase);
var enum8AsStringColumnBase = new ColumnBase<ColumnMappingBase>("Enum8AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum8AsString", enum8AsStringColumnBase);
var enum8AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("Enum8AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum8AsStringArray", enum8AsStringArrayColumnBase);
var enum8AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum8AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum8AsStringCollection", enum8AsStringCollectionColumnBase);
var enum8CollectionColumnBase = new ColumnBase<ColumnMappingBase>("Enum8Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Enum8Collection", enum8CollectionColumnBase);
var enumToNumberConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("EnumToNumberConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumToNumberConverterProperty", enumToNumberConverterPropertyColumnBase);
var enumToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("EnumToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumToStringConverterProperty", enumToStringConverterPropertyColumnBase);
var enumU16ColumnBase = new ColumnBase<ColumnMappingBase>("EnumU16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU16", enumU16ColumnBase);
var enumU16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU16Array", enumU16ArrayColumnBase);
var enumU16AsStringColumnBase = new ColumnBase<ColumnMappingBase>("EnumU16AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU16AsString", enumU16AsStringColumnBase);
var enumU16AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU16AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU16AsStringArray", enumU16AsStringArrayColumnBase);
var enumU16AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU16AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU16AsStringCollection", enumU16AsStringCollectionColumnBase);
var enumU16CollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU16Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU16Collection", enumU16CollectionColumnBase);
var enumU32ColumnBase = new ColumnBase<ColumnMappingBase>("EnumU32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU32", enumU32ColumnBase);
var enumU32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU32Array", enumU32ArrayColumnBase);
var enumU32AsStringColumnBase = new ColumnBase<ColumnMappingBase>("EnumU32AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU32AsString", enumU32AsStringColumnBase);
var enumU32AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU32AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU32AsStringArray", enumU32AsStringArrayColumnBase);
var enumU32AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU32AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU32AsStringCollection", enumU32AsStringCollectionColumnBase);
var enumU32CollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU32Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU32Collection", enumU32CollectionColumnBase);
var enumU64ColumnBase = new ColumnBase<ColumnMappingBase>("EnumU64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU64", enumU64ColumnBase);
var enumU64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU64Array", enumU64ArrayColumnBase);
var enumU64AsStringColumnBase = new ColumnBase<ColumnMappingBase>("EnumU64AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU64AsString", enumU64AsStringColumnBase);
var enumU64AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU64AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU64AsStringArray", enumU64AsStringArrayColumnBase);
var enumU64AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU64AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU64AsStringCollection", enumU64AsStringCollectionColumnBase);
var enumU64CollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU64Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU64Collection", enumU64CollectionColumnBase);
var enumU8ColumnBase = new ColumnBase<ColumnMappingBase>("EnumU8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU8", enumU8ColumnBase);
var enumU8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU8Array", enumU8ArrayColumnBase);
var enumU8AsStringColumnBase = new ColumnBase<ColumnMappingBase>("EnumU8AsString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU8AsString", enumU8AsStringColumnBase);
var enumU8AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("EnumU8AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU8AsStringArray", enumU8AsStringArrayColumnBase);
var enumU8AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU8AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU8AsStringCollection", enumU8AsStringCollectionColumnBase);
var enumU8CollectionColumnBase = new ColumnBase<ColumnMappingBase>("EnumU8Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("EnumU8Collection", enumU8CollectionColumnBase);
var floatColumnBase = new ColumnBase<ColumnMappingBase>("Float", "REAL", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Float", floatColumnBase);
var floatArrayColumnBase = new ColumnBase<ColumnMappingBase>("FloatArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("FloatArray", floatArrayColumnBase);
var guidColumnBase = new ColumnBase<ColumnMappingBase>("Guid", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Guid", guidColumnBase);
var guidArrayColumnBase = new ColumnBase<ColumnMappingBase>("GuidArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("GuidArray", guidArrayColumnBase);
var guidToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("GuidToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("GuidToBytesConverterProperty", guidToBytesConverterPropertyColumnBase);
var guidToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("GuidToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("GuidToStringConverterProperty", guidToStringConverterPropertyColumnBase);
var iPAddressColumnBase = new ColumnBase<ColumnMappingBase>("IPAddress", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IPAddress", iPAddressColumnBase);
var iPAddressArrayColumnBase = new ColumnBase<ColumnMappingBase>("IPAddressArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IPAddressArray", iPAddressArrayColumnBase);
var iPAddressReadOnlyCollectionColumnBase = new ColumnBase<ColumnMappingBase>("IPAddressReadOnlyCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IPAddressReadOnlyCollection", iPAddressReadOnlyCollectionColumnBase);
var iPAddressToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("IPAddressToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IPAddressToBytesConverterProperty", iPAddressToBytesConverterPropertyColumnBase);
var iPAddressToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("IPAddressToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IPAddressToStringConverterProperty", iPAddressToStringConverterPropertyColumnBase);
var idColumnBase2 = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Id", idColumnBase2);
var int16ColumnBase = new ColumnBase<ColumnMappingBase>("Int16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int16", int16ColumnBase);
var int16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Int16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int16Array", int16ArrayColumnBase);
var int32ColumnBase = new ColumnBase<ColumnMappingBase>("Int32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int32", int32ColumnBase);
var int32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Int32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int32Array", int32ArrayColumnBase);
var int32ReadOnlyCollectionColumnBase = new ColumnBase<ColumnMappingBase>("Int32ReadOnlyCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int32ReadOnlyCollection", int32ReadOnlyCollectionColumnBase);
var int64ColumnBase = new ColumnBase<ColumnMappingBase>("Int64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int64", int64ColumnBase);
var int64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Int64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int64Array", int64ArrayColumnBase);
var int8ColumnBase = new ColumnBase<ColumnMappingBase>("Int8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int8", int8ColumnBase);
var int8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("Int8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Int8Array", int8ArrayColumnBase);
var intNumberToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("IntNumberToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IntNumberToBytesConverterProperty", intNumberToBytesConverterPropertyColumnBase);
var intNumberToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("IntNumberToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("IntNumberToStringConverterProperty", intNumberToStringConverterPropertyColumnBase);
var nullIntToNullStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("NullIntToNullStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullIntToNullStringConverterProperty", nullIntToNullStringConverterPropertyColumnBase);
var nullableBoolColumnBase = new ColumnBase<ColumnMappingBase>("NullableBool", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableBool", nullableBoolColumnBase);
var nullableBoolArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableBoolArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableBoolArray", nullableBoolArrayColumnBase);
var nullableBytesColumnBase = new ColumnBase<ColumnMappingBase>("NullableBytes", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableBytes", nullableBytesColumnBase);
var nullableBytesArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableBytesArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableBytesArray", nullableBytesArrayColumnBase);
var nullableCharColumnBase = new ColumnBase<ColumnMappingBase>("NullableChar", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableChar", nullableCharColumnBase);
var nullableCharArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableCharArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableCharArray", nullableCharArrayColumnBase);
var nullableDateOnlyColumnBase = new ColumnBase<ColumnMappingBase>("NullableDateOnly", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDateOnly", nullableDateOnlyColumnBase);
var nullableDateOnlyArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableDateOnlyArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDateOnlyArray", nullableDateOnlyArrayColumnBase);
var nullableDateTimeColumnBase = new ColumnBase<ColumnMappingBase>("NullableDateTime", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDateTime", nullableDateTimeColumnBase);
var nullableDateTimeArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableDateTimeArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDateTimeArray", nullableDateTimeArrayColumnBase);
var nullableDecimalColumnBase = new ColumnBase<ColumnMappingBase>("NullableDecimal", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDecimal", nullableDecimalColumnBase);
var nullableDecimalArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableDecimalArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDecimalArray", nullableDecimalArrayColumnBase);
var nullableDoubleColumnBase = new ColumnBase<ColumnMappingBase>("NullableDouble", "REAL", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDouble", nullableDoubleColumnBase);
var nullableDoubleArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableDoubleArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableDoubleArray", nullableDoubleArrayColumnBase);
var nullableEnum16ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum16", nullableEnum16ColumnBase);
var nullableEnum16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum16Array", nullableEnum16ArrayColumnBase);
var nullableEnum16AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum16AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum16AsString", nullableEnum16AsStringColumnBase);
var nullableEnum16AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum16AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum16AsStringArray", nullableEnum16AsStringArrayColumnBase);
var nullableEnum16AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum16AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum16AsStringCollection", nullableEnum16AsStringCollectionColumnBase);
var nullableEnum16CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum16Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum16Collection", nullableEnum16CollectionColumnBase);
var nullableEnum32ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum32", nullableEnum32ColumnBase);
var nullableEnum32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum32Array", nullableEnum32ArrayColumnBase);
var nullableEnum32AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum32AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum32AsString", nullableEnum32AsStringColumnBase);
var nullableEnum32AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum32AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum32AsStringArray", nullableEnum32AsStringArrayColumnBase);
var nullableEnum32AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum32AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum32AsStringCollection", nullableEnum32AsStringCollectionColumnBase);
var nullableEnum32CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum32Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum32Collection", nullableEnum32CollectionColumnBase);
var nullableEnum64ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum64", nullableEnum64ColumnBase);
var nullableEnum64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum64Array", nullableEnum64ArrayColumnBase);
var nullableEnum64AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum64AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum64AsString", nullableEnum64AsStringColumnBase);
var nullableEnum64AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum64AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum64AsStringArray", nullableEnum64AsStringArrayColumnBase);
var nullableEnum64AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum64AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum64AsStringCollection", nullableEnum64AsStringCollectionColumnBase);
var nullableEnum64CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum64Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum64Collection", nullableEnum64CollectionColumnBase);
var nullableEnum8ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum8", nullableEnum8ColumnBase);
var nullableEnum8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum8Array", nullableEnum8ArrayColumnBase);
var nullableEnum8AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum8AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum8AsString", nullableEnum8AsStringColumnBase);
var nullableEnum8AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum8AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum8AsStringArray", nullableEnum8AsStringArrayColumnBase);
var nullableEnum8AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum8AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum8AsStringCollection", nullableEnum8AsStringCollectionColumnBase);
var nullableEnum8CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnum8Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnum8Collection", nullableEnum8CollectionColumnBase);
var nullableEnumU16ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU16", nullableEnumU16ColumnBase);
var nullableEnumU16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU16Array", nullableEnumU16ArrayColumnBase);
var nullableEnumU16AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU16AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU16AsString", nullableEnumU16AsStringColumnBase);
var nullableEnumU16AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU16AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU16AsStringArray", nullableEnumU16AsStringArrayColumnBase);
var nullableEnumU16AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU16AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU16AsStringCollection", nullableEnumU16AsStringCollectionColumnBase);
var nullableEnumU16CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU16Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU16Collection", nullableEnumU16CollectionColumnBase);
var nullableEnumU32ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU32", nullableEnumU32ColumnBase);
var nullableEnumU32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU32Array", nullableEnumU32ArrayColumnBase);
var nullableEnumU32AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU32AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU32AsString", nullableEnumU32AsStringColumnBase);
var nullableEnumU32AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU32AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU32AsStringArray", nullableEnumU32AsStringArrayColumnBase);
var nullableEnumU32AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU32AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU32AsStringCollection", nullableEnumU32AsStringCollectionColumnBase);
var nullableEnumU32CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU32Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU32Collection", nullableEnumU32CollectionColumnBase);
var nullableEnumU64ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU64", nullableEnumU64ColumnBase);
var nullableEnumU64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU64Array", nullableEnumU64ArrayColumnBase);
var nullableEnumU64AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU64AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU64AsString", nullableEnumU64AsStringColumnBase);
var nullableEnumU64AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU64AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU64AsStringArray", nullableEnumU64AsStringArrayColumnBase);
var nullableEnumU64AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU64AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU64AsStringCollection", nullableEnumU64AsStringCollectionColumnBase);
var nullableEnumU64CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU64Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU64Collection", nullableEnumU64CollectionColumnBase);
var nullableEnumU8ColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU8", nullableEnumU8ColumnBase);
var nullableEnumU8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU8Array", nullableEnumU8ArrayColumnBase);
var nullableEnumU8AsStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU8AsString", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU8AsString", nullableEnumU8AsStringColumnBase);
var nullableEnumU8AsStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU8AsStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU8AsStringArray", nullableEnumU8AsStringArrayColumnBase);
var nullableEnumU8AsStringCollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU8AsStringCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU8AsStringCollection", nullableEnumU8AsStringCollectionColumnBase);
var nullableEnumU8CollectionColumnBase = new ColumnBase<ColumnMappingBase>("NullableEnumU8Collection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableEnumU8Collection", nullableEnumU8CollectionColumnBase);
var nullableFloatColumnBase = new ColumnBase<ColumnMappingBase>("NullableFloat", "REAL", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableFloat", nullableFloatColumnBase);
var nullableFloatArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableFloatArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableFloatArray", nullableFloatArrayColumnBase);
var nullableGuidColumnBase = new ColumnBase<ColumnMappingBase>("NullableGuid", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableGuid", nullableGuidColumnBase);
var nullableGuidArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableGuidArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableGuidArray", nullableGuidArrayColumnBase);
var nullableIPAddressColumnBase = new ColumnBase<ColumnMappingBase>("NullableIPAddress", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableIPAddress", nullableIPAddressColumnBase);
var nullableIPAddressArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableIPAddressArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableIPAddressArray", nullableIPAddressArrayColumnBase);
var nullableInt16ColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt16", nullableInt16ColumnBase);
var nullableInt16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt16Array", nullableInt16ArrayColumnBase);
var nullableInt32ColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt32", nullableInt32ColumnBase);
var nullableInt32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt32Array", nullableInt32ArrayColumnBase);
var nullableInt64ColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt64", nullableInt64ColumnBase);
var nullableInt64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt64Array", nullableInt64ArrayColumnBase);
var nullableInt8ColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt8", nullableInt8ColumnBase);
var nullableInt8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableInt8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableInt8Array", nullableInt8ArrayColumnBase);
var nullablePhysicalAddressColumnBase = new ColumnBase<ColumnMappingBase>("NullablePhysicalAddress", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullablePhysicalAddress", nullablePhysicalAddressColumnBase);
var nullablePhysicalAddressArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullablePhysicalAddressArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullablePhysicalAddressArray", nullablePhysicalAddressArrayColumnBase);
var nullableStringColumnBase = new ColumnBase<ColumnMappingBase>("NullableString", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableString", nullableStringColumnBase);
var nullableStringArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableStringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableStringArray", nullableStringArrayColumnBase);
var nullableTimeOnlyColumnBase = new ColumnBase<ColumnMappingBase>("NullableTimeOnly", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableTimeOnly", nullableTimeOnlyColumnBase);
var nullableTimeOnlyArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableTimeOnlyArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableTimeOnlyArray", nullableTimeOnlyArrayColumnBase);
var nullableTimeSpanColumnBase = new ColumnBase<ColumnMappingBase>("NullableTimeSpan", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableTimeSpan", nullableTimeSpanColumnBase);
var nullableTimeSpanArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableTimeSpanArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableTimeSpanArray", nullableTimeSpanArrayColumnBase);
var nullableUInt16ColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt16", nullableUInt16ColumnBase);
var nullableUInt16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt16Array", nullableUInt16ArrayColumnBase);
var nullableUInt32ColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt32", nullableUInt32ColumnBase);
var nullableUInt32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt32Array", nullableUInt32ArrayColumnBase);
var nullableUInt64ColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt64", nullableUInt64ColumnBase);
var nullableUInt64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt64Array", nullableUInt64ArrayColumnBase);
var nullableUInt8ColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt8", nullableUInt8ColumnBase);
var nullableUInt8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableUInt8Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUInt8Array", nullableUInt8ArrayColumnBase);
var nullableUriColumnBase = new ColumnBase<ColumnMappingBase>("NullableUri", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUri", nullableUriColumnBase);
var nullableUriArrayColumnBase = new ColumnBase<ColumnMappingBase>("NullableUriArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("NullableUriArray", nullableUriArrayColumnBase);
var physicalAddressColumnBase = new ColumnBase<ColumnMappingBase>("PhysicalAddress", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("PhysicalAddress", physicalAddressColumnBase);
var physicalAddressArrayColumnBase = new ColumnBase<ColumnMappingBase>("PhysicalAddressArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("PhysicalAddressArray", physicalAddressArrayColumnBase);
var physicalAddressToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("PhysicalAddressToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("PhysicalAddressToBytesConverterProperty", physicalAddressToBytesConverterPropertyColumnBase);
var physicalAddressToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("PhysicalAddressToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("PhysicalAddressToStringConverterProperty", physicalAddressToStringConverterPropertyColumnBase);
var stringColumnBase = new ColumnBase<ColumnMappingBase>("String", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("String", stringColumnBase);
var stringArrayColumnBase = new ColumnBase<ColumnMappingBase>("StringArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringArray", stringArrayColumnBase);
var stringReadOnlyCollectionColumnBase = new ColumnBase<ColumnMappingBase>("StringReadOnlyCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringReadOnlyCollection", stringReadOnlyCollectionColumnBase);
var stringToBoolConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToBoolConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToBoolConverterProperty", stringToBoolConverterPropertyColumnBase);
var stringToBytesConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToBytesConverterProperty", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToBytesConverterProperty", stringToBytesConverterPropertyColumnBase);
var stringToCharConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToCharConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToCharConverterProperty", stringToCharConverterPropertyColumnBase);
var stringToDateOnlyConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToDateOnlyConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToDateOnlyConverterProperty", stringToDateOnlyConverterPropertyColumnBase);
var stringToDateTimeConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToDateTimeConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToDateTimeConverterProperty", stringToDateTimeConverterPropertyColumnBase);
var stringToDateTimeOffsetConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToDateTimeOffsetConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToDateTimeOffsetConverterProperty", stringToDateTimeOffsetConverterPropertyColumnBase);
var stringToDecimalNumberConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToDecimalNumberConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToDecimalNumberConverterProperty", stringToDecimalNumberConverterPropertyColumnBase);
var stringToDoubleNumberConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToDoubleNumberConverterProperty", "REAL", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToDoubleNumberConverterProperty", stringToDoubleNumberConverterPropertyColumnBase);
var stringToEnumConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToEnumConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToEnumConverterProperty", stringToEnumConverterPropertyColumnBase);
var stringToGuidConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToGuidConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToGuidConverterProperty", stringToGuidConverterPropertyColumnBase);
var stringToIntNumberConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToIntNumberConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToIntNumberConverterProperty", stringToIntNumberConverterPropertyColumnBase);
var stringToTimeOnlyConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToTimeOnlyConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToTimeOnlyConverterProperty", stringToTimeOnlyConverterPropertyColumnBase);
var stringToTimeSpanConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToTimeSpanConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToTimeSpanConverterProperty", stringToTimeSpanConverterPropertyColumnBase);
var stringToUriConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("StringToUriConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("StringToUriConverterProperty", stringToUriConverterPropertyColumnBase);
var timeOnlyColumnBase = new ColumnBase<ColumnMappingBase>("TimeOnly", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeOnly", timeOnlyColumnBase);
var timeOnlyArrayColumnBase = new ColumnBase<ColumnMappingBase>("TimeOnlyArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeOnlyArray", timeOnlyArrayColumnBase);
var timeOnlyToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("TimeOnlyToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeOnlyToStringConverterProperty", timeOnlyToStringConverterPropertyColumnBase);
var timeOnlyToTicksConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("TimeOnlyToTicksConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeOnlyToTicksConverterProperty", timeOnlyToTicksConverterPropertyColumnBase);
var timeSpanColumnBase = new ColumnBase<ColumnMappingBase>("TimeSpan", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeSpan", timeSpanColumnBase);
var timeSpanArrayColumnBase = new ColumnBase<ColumnMappingBase>("TimeSpanArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeSpanArray", timeSpanArrayColumnBase);
var timeSpanToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("TimeSpanToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeSpanToStringConverterProperty", timeSpanToStringConverterPropertyColumnBase);
var timeSpanToTicksConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("TimeSpanToTicksConverterProperty", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("TimeSpanToTicksConverterProperty", timeSpanToTicksConverterPropertyColumnBase);
var uInt16ColumnBase = new ColumnBase<ColumnMappingBase>("UInt16", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt16", uInt16ColumnBase);
var uInt16ArrayColumnBase = new ColumnBase<ColumnMappingBase>("UInt16Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt16Array", uInt16ArrayColumnBase);
var uInt32ColumnBase = new ColumnBase<ColumnMappingBase>("UInt32", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt32", uInt32ColumnBase);
var uInt32ArrayColumnBase = new ColumnBase<ColumnMappingBase>("UInt32Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt32Array", uInt32ArrayColumnBase);
var uInt64ColumnBase = new ColumnBase<ColumnMappingBase>("UInt64", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt64", uInt64ColumnBase);
var uInt64ArrayColumnBase = new ColumnBase<ColumnMappingBase>("UInt64Array", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt64Array", uInt64ArrayColumnBase);
var uInt8ColumnBase = new ColumnBase<ColumnMappingBase>("UInt8", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt8", uInt8ColumnBase);
var uInt8ArrayColumnBase = new ColumnBase<ColumnMappingBase>("UInt8Array", "BLOB", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt8Array", uInt8ArrayColumnBase);
var uInt8ReadOnlyCollectionColumnBase = new ColumnBase<ColumnMappingBase>("UInt8ReadOnlyCollection", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UInt8ReadOnlyCollection", uInt8ReadOnlyCollectionColumnBase);
var uriColumnBase = new ColumnBase<ColumnMappingBase>("Uri", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("Uri", uriColumnBase);
var uriArrayColumnBase = new ColumnBase<ColumnMappingBase>("UriArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UriArray", uriArrayColumnBase);
var uriToStringConverterPropertyColumnBase = new ColumnBase<ColumnMappingBase>("UriToStringConverterProperty", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.Columns.Add("UriToStringConverterProperty", uriToStringConverterPropertyColumnBase);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase = new TableMappingBase<ColumnMappingBase>(manyTypes, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase, false);
defaultTableMappings3.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase2, manyTypes.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)boolColumnBase, manyTypes.FindProperty("Bool")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)boolArrayColumnBase, manyTypes.FindProperty("BoolArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)boolReadOnlyCollectionColumnBase, manyTypes.FindProperty("BoolReadOnlyCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)boolToStringConverterPropertyColumnBase, manyTypes.FindProperty("BoolToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)boolToTwoValuesConverterPropertyColumnBase, manyTypes.FindProperty("BoolToTwoValuesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)boolToZeroOneConverterPropertyColumnBase, manyTypes.FindProperty("BoolToZeroOneConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)bytesColumnBase, manyTypes.FindProperty("Bytes")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)bytesArrayColumnBase, manyTypes.FindProperty("BytesArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)bytesToStringConverterPropertyColumnBase, manyTypes.FindProperty("BytesToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)castingConverterPropertyColumnBase, manyTypes.FindProperty("CastingConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)charColumnBase, manyTypes.FindProperty("Char")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)charArrayColumnBase, manyTypes.FindProperty("CharArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)charToStringConverterPropertyColumnBase, manyTypes.FindProperty("CharToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateOnlyColumnBase, manyTypes.FindProperty("DateOnly")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateOnlyArrayColumnBase, manyTypes.FindProperty("DateOnlyArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateOnlyToStringConverterPropertyColumnBase, manyTypes.FindProperty("DateOnlyToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeColumnBase, manyTypes.FindProperty("DateTime")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeArrayColumnBase, manyTypes.FindProperty("DateTimeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeOffsetToBinaryConverterPropertyColumnBase, manyTypes.FindProperty("DateTimeOffsetToBinaryConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeOffsetToBytesConverterPropertyColumnBase, manyTypes.FindProperty("DateTimeOffsetToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeOffsetToStringConverterPropertyColumnBase, manyTypes.FindProperty("DateTimeOffsetToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeToBinaryConverterPropertyColumnBase, manyTypes.FindProperty("DateTimeToBinaryConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeToStringConverterPropertyColumnBase, manyTypes.FindProperty("DateTimeToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)dateTimeToTicksConverterPropertyColumnBase, manyTypes.FindProperty("DateTimeToTicksConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)decimalColumnBase, manyTypes.FindProperty("Decimal")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)decimalArrayColumnBase, manyTypes.FindProperty("DecimalArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)decimalNumberToBytesConverterPropertyColumnBase, manyTypes.FindProperty("DecimalNumberToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)decimalNumberToStringConverterPropertyColumnBase, manyTypes.FindProperty("DecimalNumberToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)doubleColumnBase, manyTypes.FindProperty("Double")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)doubleArrayColumnBase, manyTypes.FindProperty("DoubleArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)doubleNumberToBytesConverterPropertyColumnBase, manyTypes.FindProperty("DoubleNumberToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)doubleNumberToStringConverterPropertyColumnBase, manyTypes.FindProperty("DoubleNumberToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum16ColumnBase, manyTypes.FindProperty("Enum16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum16ArrayColumnBase, manyTypes.FindProperty("Enum16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum16AsStringColumnBase, manyTypes.FindProperty("Enum16AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum16AsStringArrayColumnBase, manyTypes.FindProperty("Enum16AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum16AsStringCollectionColumnBase, manyTypes.FindProperty("Enum16AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum16CollectionColumnBase, manyTypes.FindProperty("Enum16Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum32ColumnBase, manyTypes.FindProperty("Enum32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum32ArrayColumnBase, manyTypes.FindProperty("Enum32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum32AsStringColumnBase, manyTypes.FindProperty("Enum32AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum32AsStringArrayColumnBase, manyTypes.FindProperty("Enum32AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum32AsStringCollectionColumnBase, manyTypes.FindProperty("Enum32AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum32CollectionColumnBase, manyTypes.FindProperty("Enum32Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum64ColumnBase, manyTypes.FindProperty("Enum64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum64ArrayColumnBase, manyTypes.FindProperty("Enum64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum64AsStringColumnBase, manyTypes.FindProperty("Enum64AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum64AsStringArrayColumnBase, manyTypes.FindProperty("Enum64AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum64AsStringCollectionColumnBase, manyTypes.FindProperty("Enum64AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum64CollectionColumnBase, manyTypes.FindProperty("Enum64Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum8ColumnBase, manyTypes.FindProperty("Enum8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum8ArrayColumnBase, manyTypes.FindProperty("Enum8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum8AsStringColumnBase, manyTypes.FindProperty("Enum8AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum8AsStringArrayColumnBase, manyTypes.FindProperty("Enum8AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum8AsStringCollectionColumnBase, manyTypes.FindProperty("Enum8AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum8CollectionColumnBase, manyTypes.FindProperty("Enum8Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumToNumberConverterPropertyColumnBase, manyTypes.FindProperty("EnumToNumberConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumToStringConverterPropertyColumnBase, manyTypes.FindProperty("EnumToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU16ColumnBase, manyTypes.FindProperty("EnumU16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU16ArrayColumnBase, manyTypes.FindProperty("EnumU16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU16AsStringColumnBase, manyTypes.FindProperty("EnumU16AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU16AsStringArrayColumnBase, manyTypes.FindProperty("EnumU16AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU16AsStringCollectionColumnBase, manyTypes.FindProperty("EnumU16AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU16CollectionColumnBase, manyTypes.FindProperty("EnumU16Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU32ColumnBase, manyTypes.FindProperty("EnumU32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU32ArrayColumnBase, manyTypes.FindProperty("EnumU32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU32AsStringColumnBase, manyTypes.FindProperty("EnumU32AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU32AsStringArrayColumnBase, manyTypes.FindProperty("EnumU32AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU32AsStringCollectionColumnBase, manyTypes.FindProperty("EnumU32AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU32CollectionColumnBase, manyTypes.FindProperty("EnumU32Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU64ColumnBase, manyTypes.FindProperty("EnumU64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU64ArrayColumnBase, manyTypes.FindProperty("EnumU64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU64AsStringColumnBase, manyTypes.FindProperty("EnumU64AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU64AsStringArrayColumnBase, manyTypes.FindProperty("EnumU64AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU64AsStringCollectionColumnBase, manyTypes.FindProperty("EnumU64AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU64CollectionColumnBase, manyTypes.FindProperty("EnumU64Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU8ColumnBase, manyTypes.FindProperty("EnumU8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU8ArrayColumnBase, manyTypes.FindProperty("EnumU8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU8AsStringColumnBase, manyTypes.FindProperty("EnumU8AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU8AsStringArrayColumnBase, manyTypes.FindProperty("EnumU8AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU8AsStringCollectionColumnBase, manyTypes.FindProperty("EnumU8AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enumU8CollectionColumnBase, manyTypes.FindProperty("EnumU8Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)floatColumnBase, manyTypes.FindProperty("Float")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)floatArrayColumnBase, manyTypes.FindProperty("FloatArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)guidColumnBase, manyTypes.FindProperty("Guid")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)guidArrayColumnBase, manyTypes.FindProperty("GuidArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)guidToBytesConverterPropertyColumnBase, manyTypes.FindProperty("GuidToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)guidToStringConverterPropertyColumnBase, manyTypes.FindProperty("GuidToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)iPAddressColumnBase, manyTypes.FindProperty("IPAddress")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)iPAddressArrayColumnBase, manyTypes.FindProperty("IPAddressArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)iPAddressReadOnlyCollectionColumnBase, manyTypes.FindProperty("IPAddressReadOnlyCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)iPAddressToBytesConverterPropertyColumnBase, manyTypes.FindProperty("IPAddressToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)iPAddressToStringConverterPropertyColumnBase, manyTypes.FindProperty("IPAddressToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int16ColumnBase, manyTypes.FindProperty("Int16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int16ArrayColumnBase, manyTypes.FindProperty("Int16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int32ColumnBase, manyTypes.FindProperty("Int32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int32ArrayColumnBase, manyTypes.FindProperty("Int32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int32ReadOnlyCollectionColumnBase, manyTypes.FindProperty("Int32ReadOnlyCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int64ColumnBase, manyTypes.FindProperty("Int64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int64ArrayColumnBase, manyTypes.FindProperty("Int64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int8ColumnBase, manyTypes.FindProperty("Int8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)int8ArrayColumnBase, manyTypes.FindProperty("Int8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)intNumberToBytesConverterPropertyColumnBase, manyTypes.FindProperty("IntNumberToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)intNumberToStringConverterPropertyColumnBase, manyTypes.FindProperty("IntNumberToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullIntToNullStringConverterPropertyColumnBase, manyTypes.FindProperty("NullIntToNullStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableBoolColumnBase, manyTypes.FindProperty("NullableBool")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableBoolArrayColumnBase, manyTypes.FindProperty("NullableBoolArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableBytesColumnBase, manyTypes.FindProperty("NullableBytes")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableBytesArrayColumnBase, manyTypes.FindProperty("NullableBytesArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableCharColumnBase, manyTypes.FindProperty("NullableChar")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableCharArrayColumnBase, manyTypes.FindProperty("NullableCharArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDateOnlyColumnBase, manyTypes.FindProperty("NullableDateOnly")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDateOnlyArrayColumnBase, manyTypes.FindProperty("NullableDateOnlyArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDateTimeColumnBase, manyTypes.FindProperty("NullableDateTime")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDateTimeArrayColumnBase, manyTypes.FindProperty("NullableDateTimeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDecimalColumnBase, manyTypes.FindProperty("NullableDecimal")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDecimalArrayColumnBase, manyTypes.FindProperty("NullableDecimalArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDoubleColumnBase, manyTypes.FindProperty("NullableDouble")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableDoubleArrayColumnBase, manyTypes.FindProperty("NullableDoubleArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum16ColumnBase, manyTypes.FindProperty("NullableEnum16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum16ArrayColumnBase, manyTypes.FindProperty("NullableEnum16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum16AsStringColumnBase, manyTypes.FindProperty("NullableEnum16AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum16AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnum16AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum16AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnum16AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum16CollectionColumnBase, manyTypes.FindProperty("NullableEnum16Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum32ColumnBase, manyTypes.FindProperty("NullableEnum32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum32ArrayColumnBase, manyTypes.FindProperty("NullableEnum32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum32AsStringColumnBase, manyTypes.FindProperty("NullableEnum32AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum32AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnum32AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum32AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnum32AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum32CollectionColumnBase, manyTypes.FindProperty("NullableEnum32Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum64ColumnBase, manyTypes.FindProperty("NullableEnum64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum64ArrayColumnBase, manyTypes.FindProperty("NullableEnum64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum64AsStringColumnBase, manyTypes.FindProperty("NullableEnum64AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum64AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnum64AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum64AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnum64AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum64CollectionColumnBase, manyTypes.FindProperty("NullableEnum64Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum8ColumnBase, manyTypes.FindProperty("NullableEnum8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum8ArrayColumnBase, manyTypes.FindProperty("NullableEnum8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum8AsStringColumnBase, manyTypes.FindProperty("NullableEnum8AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum8AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnum8AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum8AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnum8AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnum8CollectionColumnBase, manyTypes.FindProperty("NullableEnum8Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU16ColumnBase, manyTypes.FindProperty("NullableEnumU16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU16ArrayColumnBase, manyTypes.FindProperty("NullableEnumU16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU16AsStringColumnBase, manyTypes.FindProperty("NullableEnumU16AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU16AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnumU16AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU16AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnumU16AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU16CollectionColumnBase, manyTypes.FindProperty("NullableEnumU16Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU32ColumnBase, manyTypes.FindProperty("NullableEnumU32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU32ArrayColumnBase, manyTypes.FindProperty("NullableEnumU32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU32AsStringColumnBase, manyTypes.FindProperty("NullableEnumU32AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU32AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnumU32AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU32AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnumU32AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU32CollectionColumnBase, manyTypes.FindProperty("NullableEnumU32Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU64ColumnBase, manyTypes.FindProperty("NullableEnumU64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU64ArrayColumnBase, manyTypes.FindProperty("NullableEnumU64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU64AsStringColumnBase, manyTypes.FindProperty("NullableEnumU64AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU64AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnumU64AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU64AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnumU64AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU64CollectionColumnBase, manyTypes.FindProperty("NullableEnumU64Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU8ColumnBase, manyTypes.FindProperty("NullableEnumU8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU8ArrayColumnBase, manyTypes.FindProperty("NullableEnumU8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU8AsStringColumnBase, manyTypes.FindProperty("NullableEnumU8AsString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU8AsStringArrayColumnBase, manyTypes.FindProperty("NullableEnumU8AsStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU8AsStringCollectionColumnBase, manyTypes.FindProperty("NullableEnumU8AsStringCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableEnumU8CollectionColumnBase, manyTypes.FindProperty("NullableEnumU8Collection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableFloatColumnBase, manyTypes.FindProperty("NullableFloat")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableFloatArrayColumnBase, manyTypes.FindProperty("NullableFloatArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableGuidColumnBase, manyTypes.FindProperty("NullableGuid")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableGuidArrayColumnBase, manyTypes.FindProperty("NullableGuidArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableIPAddressColumnBase, manyTypes.FindProperty("NullableIPAddress")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableIPAddressArrayColumnBase, manyTypes.FindProperty("NullableIPAddressArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt16ColumnBase, manyTypes.FindProperty("NullableInt16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt16ArrayColumnBase, manyTypes.FindProperty("NullableInt16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt32ColumnBase, manyTypes.FindProperty("NullableInt32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt32ArrayColumnBase, manyTypes.FindProperty("NullableInt32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt64ColumnBase, manyTypes.FindProperty("NullableInt64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt64ArrayColumnBase, manyTypes.FindProperty("NullableInt64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt8ColumnBase, manyTypes.FindProperty("NullableInt8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableInt8ArrayColumnBase, manyTypes.FindProperty("NullableInt8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullablePhysicalAddressColumnBase, manyTypes.FindProperty("NullablePhysicalAddress")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullablePhysicalAddressArrayColumnBase, manyTypes.FindProperty("NullablePhysicalAddressArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableStringColumnBase, manyTypes.FindProperty("NullableString")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableStringArrayColumnBase, manyTypes.FindProperty("NullableStringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableTimeOnlyColumnBase, manyTypes.FindProperty("NullableTimeOnly")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableTimeOnlyArrayColumnBase, manyTypes.FindProperty("NullableTimeOnlyArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableTimeSpanColumnBase, manyTypes.FindProperty("NullableTimeSpan")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableTimeSpanArrayColumnBase, manyTypes.FindProperty("NullableTimeSpanArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt16ColumnBase, manyTypes.FindProperty("NullableUInt16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt16ArrayColumnBase, manyTypes.FindProperty("NullableUInt16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt32ColumnBase, manyTypes.FindProperty("NullableUInt32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt32ArrayColumnBase, manyTypes.FindProperty("NullableUInt32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt64ColumnBase, manyTypes.FindProperty("NullableUInt64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt64ArrayColumnBase, manyTypes.FindProperty("NullableUInt64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt8ColumnBase, manyTypes.FindProperty("NullableUInt8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUInt8ArrayColumnBase, manyTypes.FindProperty("NullableUInt8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUriColumnBase, manyTypes.FindProperty("NullableUri")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)nullableUriArrayColumnBase, manyTypes.FindProperty("NullableUriArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)physicalAddressColumnBase, manyTypes.FindProperty("PhysicalAddress")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)physicalAddressArrayColumnBase, manyTypes.FindProperty("PhysicalAddressArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)physicalAddressToBytesConverterPropertyColumnBase, manyTypes.FindProperty("PhysicalAddressToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)physicalAddressToStringConverterPropertyColumnBase, manyTypes.FindProperty("PhysicalAddressToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringColumnBase, manyTypes.FindProperty("String")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringArrayColumnBase, manyTypes.FindProperty("StringArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringReadOnlyCollectionColumnBase, manyTypes.FindProperty("StringReadOnlyCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToBoolConverterPropertyColumnBase, manyTypes.FindProperty("StringToBoolConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToBytesConverterPropertyColumnBase, manyTypes.FindProperty("StringToBytesConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToCharConverterPropertyColumnBase, manyTypes.FindProperty("StringToCharConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToDateOnlyConverterPropertyColumnBase, manyTypes.FindProperty("StringToDateOnlyConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToDateTimeConverterPropertyColumnBase, manyTypes.FindProperty("StringToDateTimeConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToDateTimeOffsetConverterPropertyColumnBase, manyTypes.FindProperty("StringToDateTimeOffsetConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToDecimalNumberConverterPropertyColumnBase, manyTypes.FindProperty("StringToDecimalNumberConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToDoubleNumberConverterPropertyColumnBase, manyTypes.FindProperty("StringToDoubleNumberConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToEnumConverterPropertyColumnBase, manyTypes.FindProperty("StringToEnumConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToGuidConverterPropertyColumnBase, manyTypes.FindProperty("StringToGuidConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToIntNumberConverterPropertyColumnBase, manyTypes.FindProperty("StringToIntNumberConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToTimeOnlyConverterPropertyColumnBase, manyTypes.FindProperty("StringToTimeOnlyConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToTimeSpanConverterPropertyColumnBase, manyTypes.FindProperty("StringToTimeSpanConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)stringToUriConverterPropertyColumnBase, manyTypes.FindProperty("StringToUriConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeOnlyColumnBase, manyTypes.FindProperty("TimeOnly")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeOnlyArrayColumnBase, manyTypes.FindProperty("TimeOnlyArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeOnlyToStringConverterPropertyColumnBase, manyTypes.FindProperty("TimeOnlyToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeOnlyToTicksConverterPropertyColumnBase, manyTypes.FindProperty("TimeOnlyToTicksConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeSpanColumnBase, manyTypes.FindProperty("TimeSpan")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeSpanArrayColumnBase, manyTypes.FindProperty("TimeSpanArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeSpanToStringConverterPropertyColumnBase, manyTypes.FindProperty("TimeSpanToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)timeSpanToTicksConverterPropertyColumnBase, manyTypes.FindProperty("TimeSpanToTicksConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt16ColumnBase, manyTypes.FindProperty("UInt16")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt16ArrayColumnBase, manyTypes.FindProperty("UInt16Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt32ColumnBase, manyTypes.FindProperty("UInt32")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt32ArrayColumnBase, manyTypes.FindProperty("UInt32Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt64ColumnBase, manyTypes.FindProperty("UInt64")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt64ArrayColumnBase, manyTypes.FindProperty("UInt64Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt8ColumnBase, manyTypes.FindProperty("UInt8")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt8ArrayColumnBase, manyTypes.FindProperty("UInt8Array")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uInt8ReadOnlyCollectionColumnBase, manyTypes.FindProperty("UInt8ReadOnlyCollection")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uriColumnBase, manyTypes.FindProperty("Uri")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uriArrayColumnBase, manyTypes.FindProperty("UriArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)uriToStringConverterPropertyColumnBase, manyTypes.FindProperty("UriToStringConverterProperty")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseManyTypesMappingBase);
var tableMappings3 = new List<TableMapping>();
manyTypes.SetRuntimeAnnotation("Relational:TableMappings", tableMappings3);
var manyTypesTable = new Table("ManyTypes", null, relationalModel);
var idColumn2 = new Column("Id", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Id", idColumn2);
idColumn2.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(idColumn2);
var boolColumn = new Column("Bool", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Bool", boolColumn);
boolColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<bool>(boolColumn);
var boolArrayColumn = new Column("BoolArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("BoolArray", boolArrayColumn);
boolArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(boolArrayColumn);
var boolReadOnlyCollectionColumn = new Column("BoolReadOnlyCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("BoolReadOnlyCollection", boolReadOnlyCollectionColumn);
boolReadOnlyCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(boolReadOnlyCollectionColumn);
var boolToStringConverterPropertyColumn = new Column("BoolToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("BoolToStringConverterProperty", boolToStringConverterPropertyColumn);
boolToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(boolToStringConverterPropertyColumn);
var boolToTwoValuesConverterPropertyColumn = new Column("BoolToTwoValuesConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("BoolToTwoValuesConverterProperty", boolToTwoValuesConverterPropertyColumn);
boolToTwoValuesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(boolToTwoValuesConverterPropertyColumn);
var boolToZeroOneConverterPropertyColumn = new Column("BoolToZeroOneConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("BoolToZeroOneConverterProperty", boolToZeroOneConverterPropertyColumn);
boolToZeroOneConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<short>(boolToZeroOneConverterPropertyColumn);
var bytesColumn = new Column("Bytes", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("Bytes", bytesColumn);
bytesColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(bytesColumn);
var bytesArrayColumn = new Column("BytesArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("BytesArray", bytesArrayColumn);
bytesArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(bytesArrayColumn);
var bytesToStringConverterPropertyColumn = new Column("BytesToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("BytesToStringConverterProperty", bytesToStringConverterPropertyColumn);
bytesToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(bytesToStringConverterPropertyColumn);
var castingConverterPropertyColumn = new Column("CastingConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("CastingConverterProperty", castingConverterPropertyColumn);
castingConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<decimal>(castingConverterPropertyColumn);
var charColumn = new Column("Char", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Char", charColumn);
charColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<char>(charColumn);
var charArrayColumn = new Column("CharArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("CharArray", charArrayColumn);
charArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(charArrayColumn);
var charToStringConverterPropertyColumn = new Column("CharToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("CharToStringConverterProperty", charToStringConverterPropertyColumn);
charToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(charToStringConverterPropertyColumn);
var dateOnlyColumn = new Column("DateOnly", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateOnly", dateOnlyColumn);
dateOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateOnly>(dateOnlyColumn);
var dateOnlyArrayColumn = new Column("DateOnlyArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateOnlyArray", dateOnlyArrayColumn);
dateOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(dateOnlyArrayColumn);
var dateOnlyToStringConverterPropertyColumn = new Column("DateOnlyToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateOnlyToStringConverterProperty", dateOnlyToStringConverterPropertyColumn);
dateOnlyToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(dateOnlyToStringConverterPropertyColumn);
var dateTimeColumn = new Column("DateTime", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateTime", dateTimeColumn);
dateTimeColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateTime>(dateTimeColumn);
var dateTimeArrayColumn = new Column("DateTimeArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeArray", dateTimeArrayColumn);
dateTimeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(dateTimeArrayColumn);
var dateTimeOffsetToBinaryConverterPropertyColumn = new Column("DateTimeOffsetToBinaryConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeOffsetToBinaryConverterProperty", dateTimeOffsetToBinaryConverterPropertyColumn);
dateTimeOffsetToBinaryConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(dateTimeOffsetToBinaryConverterPropertyColumn);
var dateTimeOffsetToBytesConverterPropertyColumn = new Column("DateTimeOffsetToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeOffsetToBytesConverterProperty", dateTimeOffsetToBytesConverterPropertyColumn);
dateTimeOffsetToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(dateTimeOffsetToBytesConverterPropertyColumn);
var dateTimeOffsetToStringConverterPropertyColumn = new Column("DateTimeOffsetToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeOffsetToStringConverterProperty", dateTimeOffsetToStringConverterPropertyColumn);
dateTimeOffsetToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(dateTimeOffsetToStringConverterPropertyColumn);
var dateTimeToBinaryConverterPropertyColumn = new Column("DateTimeToBinaryConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeToBinaryConverterProperty", dateTimeToBinaryConverterPropertyColumn);
dateTimeToBinaryConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(dateTimeToBinaryConverterPropertyColumn);
var dateTimeToStringConverterPropertyColumn = new Column("DateTimeToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeToStringConverterProperty", dateTimeToStringConverterPropertyColumn);
dateTimeToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(dateTimeToStringConverterPropertyColumn);
var dateTimeToTicksConverterPropertyColumn = new Column("DateTimeToTicksConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DateTimeToTicksConverterProperty", dateTimeToTicksConverterPropertyColumn);
dateTimeToTicksConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateTime>(dateTimeToTicksConverterPropertyColumn);
var decimalColumn = new Column("Decimal", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Decimal", decimalColumn);
decimalColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<decimal>(decimalColumn);
var decimalArrayColumn = new Column("DecimalArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DecimalArray", decimalArrayColumn);
decimalArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(decimalArrayColumn);
var decimalNumberToBytesConverterPropertyColumn = new Column("DecimalNumberToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("DecimalNumberToBytesConverterProperty", decimalNumberToBytesConverterPropertyColumn);
decimalNumberToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(decimalNumberToBytesConverterPropertyColumn);
var decimalNumberToStringConverterPropertyColumn = new Column("DecimalNumberToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DecimalNumberToStringConverterProperty", decimalNumberToStringConverterPropertyColumn);
decimalNumberToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(decimalNumberToStringConverterPropertyColumn);
var doubleColumn = new Column("Double", "REAL", manyTypesTable);
manyTypesTable.Columns.Add("Double", doubleColumn);
doubleColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<double>(doubleColumn);
var doubleArrayColumn = new Column("DoubleArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DoubleArray", doubleArrayColumn);
doubleArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(doubleArrayColumn);
var doubleNumberToBytesConverterPropertyColumn = new Column("DoubleNumberToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("DoubleNumberToBytesConverterProperty", doubleNumberToBytesConverterPropertyColumn);
doubleNumberToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(doubleNumberToBytesConverterPropertyColumn);
var doubleNumberToStringConverterPropertyColumn = new Column("DoubleNumberToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("DoubleNumberToStringConverterProperty", doubleNumberToStringConverterPropertyColumn);
doubleNumberToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(doubleNumberToStringConverterPropertyColumn);
var enum16Column = new Column("Enum16", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Enum16", enum16Column);
enum16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<short>(enum16Column);
var enum16ArrayColumn = new Column("Enum16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum16Array", enum16ArrayColumn);
enum16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum16ArrayColumn);
var enum16AsStringColumn = new Column("Enum16AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum16AsString", enum16AsStringColumn);
enum16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum16AsStringColumn);
var enum16AsStringArrayColumn = new Column("Enum16AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum16AsStringArray", enum16AsStringArrayColumn);
enum16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum16AsStringArrayColumn);
var enum16AsStringCollectionColumn = new Column("Enum16AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum16AsStringCollection", enum16AsStringCollectionColumn);
enum16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum16AsStringCollectionColumn);
var enum16CollectionColumn = new Column("Enum16Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum16Collection", enum16CollectionColumn);
enum16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum16CollectionColumn);
var enum32Column = new Column("Enum32", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Enum32", enum32Column);
enum32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(enum32Column);
var enum32ArrayColumn = new Column("Enum32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum32Array", enum32ArrayColumn);
enum32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum32ArrayColumn);
var enum32AsStringColumn = new Column("Enum32AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum32AsString", enum32AsStringColumn);
enum32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum32AsStringColumn);
var enum32AsStringArrayColumn = new Column("Enum32AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum32AsStringArray", enum32AsStringArrayColumn);
enum32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum32AsStringArrayColumn);
var enum32AsStringCollectionColumn = new Column("Enum32AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum32AsStringCollection", enum32AsStringCollectionColumn);
enum32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum32AsStringCollectionColumn);
var enum32CollectionColumn = new Column("Enum32Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum32Collection", enum32CollectionColumn);
enum32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum32CollectionColumn);
var enum64Column = new Column("Enum64", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Enum64", enum64Column);
enum64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(enum64Column);
var enum64ArrayColumn = new Column("Enum64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum64Array", enum64ArrayColumn);
enum64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum64ArrayColumn);
var enum64AsStringColumn = new Column("Enum64AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum64AsString", enum64AsStringColumn);
enum64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum64AsStringColumn);
var enum64AsStringArrayColumn = new Column("Enum64AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum64AsStringArray", enum64AsStringArrayColumn);
enum64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum64AsStringArrayColumn);
var enum64AsStringCollectionColumn = new Column("Enum64AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum64AsStringCollection", enum64AsStringCollectionColumn);
enum64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum64AsStringCollectionColumn);
var enum64CollectionColumn = new Column("Enum64Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum64Collection", enum64CollectionColumn);
enum64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum64CollectionColumn);
var enum8Column = new Column("Enum8", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Enum8", enum8Column);
enum8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<sbyte>(enum8Column);
var enum8ArrayColumn = new Column("Enum8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum8Array", enum8ArrayColumn);
enum8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum8ArrayColumn);
var enum8AsStringColumn = new Column("Enum8AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum8AsString", enum8AsStringColumn);
enum8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum8AsStringColumn);
var enum8AsStringArrayColumn = new Column("Enum8AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum8AsStringArray", enum8AsStringArrayColumn);
enum8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum8AsStringArrayColumn);
var enum8AsStringCollectionColumn = new Column("Enum8AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum8AsStringCollection", enum8AsStringCollectionColumn);
enum8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum8AsStringCollectionColumn);
var enum8CollectionColumn = new Column("Enum8Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Enum8Collection", enum8CollectionColumn);
enum8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enum8CollectionColumn);
var enumToNumberConverterPropertyColumn = new Column("EnumToNumberConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("EnumToNumberConverterProperty", enumToNumberConverterPropertyColumn);
enumToNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(enumToNumberConverterPropertyColumn);
var enumToStringConverterPropertyColumn = new Column("EnumToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumToStringConverterProperty", enumToStringConverterPropertyColumn);
enumToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumToStringConverterPropertyColumn);
var enumU16Column = new Column("EnumU16", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("EnumU16", enumU16Column);
enumU16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ushort>(enumU16Column);
var enumU16ArrayColumn = new Column("EnumU16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU16Array", enumU16ArrayColumn);
enumU16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU16ArrayColumn);
var enumU16AsStringColumn = new Column("EnumU16AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU16AsString", enumU16AsStringColumn);
enumU16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU16AsStringColumn);
var enumU16AsStringArrayColumn = new Column("EnumU16AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU16AsStringArray", enumU16AsStringArrayColumn);
enumU16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU16AsStringArrayColumn);
var enumU16AsStringCollectionColumn = new Column("EnumU16AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU16AsStringCollection", enumU16AsStringCollectionColumn);
enumU16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU16AsStringCollectionColumn);
var enumU16CollectionColumn = new Column("EnumU16Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU16Collection", enumU16CollectionColumn);
enumU16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU16CollectionColumn);
var enumU32Column = new Column("EnumU32", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("EnumU32", enumU32Column);
enumU32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<uint>(enumU32Column);
var enumU32ArrayColumn = new Column("EnumU32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU32Array", enumU32ArrayColumn);
enumU32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU32ArrayColumn);
var enumU32AsStringColumn = new Column("EnumU32AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU32AsString", enumU32AsStringColumn);
enumU32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU32AsStringColumn);
var enumU32AsStringArrayColumn = new Column("EnumU32AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU32AsStringArray", enumU32AsStringArrayColumn);
enumU32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU32AsStringArrayColumn);
var enumU32AsStringCollectionColumn = new Column("EnumU32AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU32AsStringCollection", enumU32AsStringCollectionColumn);
enumU32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU32AsStringCollectionColumn);
var enumU32CollectionColumn = new Column("EnumU32Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU32Collection", enumU32CollectionColumn);
enumU32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU32CollectionColumn);
var enumU64Column = new Column("EnumU64", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("EnumU64", enumU64Column);
enumU64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ulong>(enumU64Column);
var enumU64ArrayColumn = new Column("EnumU64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU64Array", enumU64ArrayColumn);
enumU64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU64ArrayColumn);
var enumU64AsStringColumn = new Column("EnumU64AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU64AsString", enumU64AsStringColumn);
enumU64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU64AsStringColumn);
var enumU64AsStringArrayColumn = new Column("EnumU64AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU64AsStringArray", enumU64AsStringArrayColumn);
enumU64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU64AsStringArrayColumn);
var enumU64AsStringCollectionColumn = new Column("EnumU64AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU64AsStringCollection", enumU64AsStringCollectionColumn);
enumU64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU64AsStringCollectionColumn);
var enumU64CollectionColumn = new Column("EnumU64Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU64Collection", enumU64CollectionColumn);
enumU64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU64CollectionColumn);
var enumU8Column = new Column("EnumU8", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("EnumU8", enumU8Column);
enumU8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(enumU8Column);
var enumU8ArrayColumn = new Column("EnumU8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU8Array", enumU8ArrayColumn);
enumU8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU8ArrayColumn);
var enumU8AsStringColumn = new Column("EnumU8AsString", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU8AsString", enumU8AsStringColumn);
enumU8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU8AsStringColumn);
var enumU8AsStringArrayColumn = new Column("EnumU8AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU8AsStringArray", enumU8AsStringArrayColumn);
enumU8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU8AsStringArrayColumn);
var enumU8AsStringCollectionColumn = new Column("EnumU8AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU8AsStringCollection", enumU8AsStringCollectionColumn);
enumU8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU8AsStringCollectionColumn);
var enumU8CollectionColumn = new Column("EnumU8Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("EnumU8Collection", enumU8CollectionColumn);
enumU8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(enumU8CollectionColumn);
var floatColumn = new Column("Float", "REAL", manyTypesTable);
manyTypesTable.Columns.Add("Float", floatColumn);
floatColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<float>(floatColumn);
var floatArrayColumn = new Column("FloatArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("FloatArray", floatArrayColumn);
floatArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(floatArrayColumn);
var guidColumn = new Column("Guid", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Guid", guidColumn);
guidColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(guidColumn);
var guidArrayColumn = new Column("GuidArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("GuidArray", guidArrayColumn);
guidArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(guidArrayColumn);
var guidToBytesConverterPropertyColumn = new Column("GuidToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("GuidToBytesConverterProperty", guidToBytesConverterPropertyColumn);
guidToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(guidToBytesConverterPropertyColumn);
var guidToStringConverterPropertyColumn = new Column("GuidToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("GuidToStringConverterProperty", guidToStringConverterPropertyColumn);
guidToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(guidToStringConverterPropertyColumn);
var iPAddressColumn = new Column("IPAddress", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("IPAddress", iPAddressColumn);
iPAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(iPAddressColumn);
var iPAddressArrayColumn = new Column("IPAddressArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("IPAddressArray", iPAddressArrayColumn);
iPAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(iPAddressArrayColumn);
var iPAddressReadOnlyCollectionColumn = new Column("IPAddressReadOnlyCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("IPAddressReadOnlyCollection", iPAddressReadOnlyCollectionColumn);
iPAddressReadOnlyCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(iPAddressReadOnlyCollectionColumn);
var iPAddressToBytesConverterPropertyColumn = new Column("IPAddressToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("IPAddressToBytesConverterProperty", iPAddressToBytesConverterPropertyColumn);
iPAddressToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(iPAddressToBytesConverterPropertyColumn);
var iPAddressToStringConverterPropertyColumn = new Column("IPAddressToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("IPAddressToStringConverterProperty", iPAddressToStringConverterPropertyColumn);
iPAddressToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(iPAddressToStringConverterPropertyColumn);
var int16Column = new Column("Int16", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Int16", int16Column);
int16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<short>(int16Column);
var int16ArrayColumn = new Column("Int16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Int16Array", int16ArrayColumn);
int16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(int16ArrayColumn);
var int32Column = new Column("Int32", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Int32", int32Column);
int32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(int32Column);
var int32ArrayColumn = new Column("Int32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Int32Array", int32ArrayColumn);
int32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(int32ArrayColumn);
var int32ReadOnlyCollectionColumn = new Column("Int32ReadOnlyCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Int32ReadOnlyCollection", int32ReadOnlyCollectionColumn);
int32ReadOnlyCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(int32ReadOnlyCollectionColumn);
var int64Column = new Column("Int64", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Int64", int64Column);
int64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(int64Column);
var int64ArrayColumn = new Column("Int64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Int64Array", int64ArrayColumn);
int64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(int64ArrayColumn);
var int8Column = new Column("Int8", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("Int8", int8Column);
int8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<sbyte>(int8Column);
var int8ArrayColumn = new Column("Int8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Int8Array", int8ArrayColumn);
int8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(int8ArrayColumn);
var intNumberToBytesConverterPropertyColumn = new Column("IntNumberToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("IntNumberToBytesConverterProperty", intNumberToBytesConverterPropertyColumn);
intNumberToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(intNumberToBytesConverterPropertyColumn);
var intNumberToStringConverterPropertyColumn = new Column("IntNumberToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("IntNumberToStringConverterProperty", intNumberToStringConverterPropertyColumn);
intNumberToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(intNumberToStringConverterPropertyColumn);
var nullIntToNullStringConverterPropertyColumn = new Column("NullIntToNullStringConverterProperty", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullIntToNullStringConverterProperty", nullIntToNullStringConverterPropertyColumn);
nullIntToNullStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullIntToNullStringConverterPropertyColumn);
var nullableBoolColumn = new Column("NullableBool", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableBool", nullableBoolColumn);
nullableBoolColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<bool>(nullableBoolColumn);
var nullableBoolArrayColumn = new Column("NullableBoolArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableBoolArray", nullableBoolArrayColumn);
nullableBoolArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableBoolArrayColumn);
var nullableBytesColumn = new Column("NullableBytes", "BLOB", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableBytes", nullableBytesColumn);
nullableBytesColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(nullableBytesColumn);
var nullableBytesArrayColumn = new Column("NullableBytesArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableBytesArray", nullableBytesArrayColumn);
nullableBytesArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableBytesArrayColumn);
var nullableCharColumn = new Column("NullableChar", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableChar", nullableCharColumn);
nullableCharColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<char>(nullableCharColumn);
var nullableCharArrayColumn = new Column("NullableCharArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableCharArray", nullableCharArrayColumn);
nullableCharArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableCharArrayColumn);
var nullableDateOnlyColumn = new Column("NullableDateOnly", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableDateOnly", nullableDateOnlyColumn);
nullableDateOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateOnly>(nullableDateOnlyColumn);
var nullableDateOnlyArrayColumn = new Column("NullableDateOnlyArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableDateOnlyArray", nullableDateOnlyArrayColumn);
nullableDateOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableDateOnlyArrayColumn);
var nullableDateTimeColumn = new Column("NullableDateTime", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableDateTime", nullableDateTimeColumn);
nullableDateTimeColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateTime>(nullableDateTimeColumn);
var nullableDateTimeArrayColumn = new Column("NullableDateTimeArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableDateTimeArray", nullableDateTimeArrayColumn);
nullableDateTimeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableDateTimeArrayColumn);
var nullableDecimalColumn = new Column("NullableDecimal", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableDecimal", nullableDecimalColumn);
nullableDecimalColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<decimal>(nullableDecimalColumn);
var nullableDecimalArrayColumn = new Column("NullableDecimalArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableDecimalArray", nullableDecimalArrayColumn);
nullableDecimalArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableDecimalArrayColumn);
var nullableDoubleColumn = new Column("NullableDouble", "REAL", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableDouble", nullableDoubleColumn);
nullableDoubleColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<double>(nullableDoubleColumn);
var nullableDoubleArrayColumn = new Column("NullableDoubleArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableDoubleArray", nullableDoubleArrayColumn);
nullableDoubleArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableDoubleArrayColumn);
var nullableEnum16Column = new Column("NullableEnum16", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum16", nullableEnum16Column);
nullableEnum16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<short>(nullableEnum16Column);
var nullableEnum16ArrayColumn = new Column("NullableEnum16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum16Array", nullableEnum16ArrayColumn);
nullableEnum16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum16ArrayColumn);
var nullableEnum16AsStringColumn = new Column("NullableEnum16AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum16AsString", nullableEnum16AsStringColumn);
nullableEnum16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<short>(nullableEnum16AsStringColumn);
var nullableEnum16AsStringArrayColumn = new Column("NullableEnum16AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum16AsStringArray", nullableEnum16AsStringArrayColumn);
nullableEnum16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum16AsStringArrayColumn);
var nullableEnum16AsStringCollectionColumn = new Column("NullableEnum16AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum16AsStringCollection", nullableEnum16AsStringCollectionColumn);
nullableEnum16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum16AsStringCollectionColumn);
var nullableEnum16CollectionColumn = new Column("NullableEnum16Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum16Collection", nullableEnum16CollectionColumn);
nullableEnum16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum16CollectionColumn);
var nullableEnum32Column = new Column("NullableEnum32", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum32", nullableEnum32Column);
nullableEnum32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(nullableEnum32Column);
var nullableEnum32ArrayColumn = new Column("NullableEnum32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum32Array", nullableEnum32ArrayColumn);
nullableEnum32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum32ArrayColumn);
var nullableEnum32AsStringColumn = new Column("NullableEnum32AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum32AsString", nullableEnum32AsStringColumn);
nullableEnum32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(nullableEnum32AsStringColumn);
var nullableEnum32AsStringArrayColumn = new Column("NullableEnum32AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum32AsStringArray", nullableEnum32AsStringArrayColumn);
nullableEnum32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum32AsStringArrayColumn);
var nullableEnum32AsStringCollectionColumn = new Column("NullableEnum32AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum32AsStringCollection", nullableEnum32AsStringCollectionColumn);
nullableEnum32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum32AsStringCollectionColumn);
var nullableEnum32CollectionColumn = new Column("NullableEnum32Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum32Collection", nullableEnum32CollectionColumn);
nullableEnum32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum32CollectionColumn);
var nullableEnum64Column = new Column("NullableEnum64", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum64", nullableEnum64Column);
nullableEnum64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(nullableEnum64Column);
var nullableEnum64ArrayColumn = new Column("NullableEnum64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum64Array", nullableEnum64ArrayColumn);
nullableEnum64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum64ArrayColumn);
var nullableEnum64AsStringColumn = new Column("NullableEnum64AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum64AsString", nullableEnum64AsStringColumn);
nullableEnum64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(nullableEnum64AsStringColumn);
var nullableEnum64AsStringArrayColumn = new Column("NullableEnum64AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum64AsStringArray", nullableEnum64AsStringArrayColumn);
nullableEnum64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum64AsStringArrayColumn);
var nullableEnum64AsStringCollectionColumn = new Column("NullableEnum64AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum64AsStringCollection", nullableEnum64AsStringCollectionColumn);
nullableEnum64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum64AsStringCollectionColumn);
var nullableEnum64CollectionColumn = new Column("NullableEnum64Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum64Collection", nullableEnum64CollectionColumn);
nullableEnum64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum64CollectionColumn);
var nullableEnum8Column = new Column("NullableEnum8", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum8", nullableEnum8Column);
nullableEnum8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<sbyte>(nullableEnum8Column);
var nullableEnum8ArrayColumn = new Column("NullableEnum8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum8Array", nullableEnum8ArrayColumn);
nullableEnum8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum8ArrayColumn);
var nullableEnum8AsStringColumn = new Column("NullableEnum8AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnum8AsString", nullableEnum8AsStringColumn);
nullableEnum8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<sbyte>(nullableEnum8AsStringColumn);
var nullableEnum8AsStringArrayColumn = new Column("NullableEnum8AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum8AsStringArray", nullableEnum8AsStringArrayColumn);
nullableEnum8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum8AsStringArrayColumn);
var nullableEnum8AsStringCollectionColumn = new Column("NullableEnum8AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum8AsStringCollection", nullableEnum8AsStringCollectionColumn);
nullableEnum8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum8AsStringCollectionColumn);
var nullableEnum8CollectionColumn = new Column("NullableEnum8Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnum8Collection", nullableEnum8CollectionColumn);
nullableEnum8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnum8CollectionColumn);
var nullableEnumU16Column = new Column("NullableEnumU16", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU16", nullableEnumU16Column);
nullableEnumU16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ushort>(nullableEnumU16Column);
var nullableEnumU16ArrayColumn = new Column("NullableEnumU16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU16Array", nullableEnumU16ArrayColumn);
nullableEnumU16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU16ArrayColumn);
var nullableEnumU16AsStringColumn = new Column("NullableEnumU16AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU16AsString", nullableEnumU16AsStringColumn);
nullableEnumU16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<ushort>(nullableEnumU16AsStringColumn);
var nullableEnumU16AsStringArrayColumn = new Column("NullableEnumU16AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU16AsStringArray", nullableEnumU16AsStringArrayColumn);
nullableEnumU16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU16AsStringArrayColumn);
var nullableEnumU16AsStringCollectionColumn = new Column("NullableEnumU16AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU16AsStringCollection", nullableEnumU16AsStringCollectionColumn);
nullableEnumU16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU16AsStringCollectionColumn);
var nullableEnumU16CollectionColumn = new Column("NullableEnumU16Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU16Collection", nullableEnumU16CollectionColumn);
nullableEnumU16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU16CollectionColumn);
var nullableEnumU32Column = new Column("NullableEnumU32", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU32", nullableEnumU32Column);
nullableEnumU32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<uint>(nullableEnumU32Column);
var nullableEnumU32ArrayColumn = new Column("NullableEnumU32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU32Array", nullableEnumU32ArrayColumn);
nullableEnumU32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU32ArrayColumn);
var nullableEnumU32AsStringColumn = new Column("NullableEnumU32AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU32AsString", nullableEnumU32AsStringColumn);
nullableEnumU32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<uint>(nullableEnumU32AsStringColumn);
var nullableEnumU32AsStringArrayColumn = new Column("NullableEnumU32AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU32AsStringArray", nullableEnumU32AsStringArrayColumn);
nullableEnumU32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU32AsStringArrayColumn);
var nullableEnumU32AsStringCollectionColumn = new Column("NullableEnumU32AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU32AsStringCollection", nullableEnumU32AsStringCollectionColumn);
nullableEnumU32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU32AsStringCollectionColumn);
var nullableEnumU32CollectionColumn = new Column("NullableEnumU32Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU32Collection", nullableEnumU32CollectionColumn);
nullableEnumU32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU32CollectionColumn);
var nullableEnumU64Column = new Column("NullableEnumU64", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU64", nullableEnumU64Column);
nullableEnumU64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ulong>(nullableEnumU64Column);
var nullableEnumU64ArrayColumn = new Column("NullableEnumU64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU64Array", nullableEnumU64ArrayColumn);
nullableEnumU64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU64ArrayColumn);
var nullableEnumU64AsStringColumn = new Column("NullableEnumU64AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU64AsString", nullableEnumU64AsStringColumn);
nullableEnumU64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<ulong>(nullableEnumU64AsStringColumn);
var nullableEnumU64AsStringArrayColumn = new Column("NullableEnumU64AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU64AsStringArray", nullableEnumU64AsStringArrayColumn);
nullableEnumU64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU64AsStringArrayColumn);
var nullableEnumU64AsStringCollectionColumn = new Column("NullableEnumU64AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU64AsStringCollection", nullableEnumU64AsStringCollectionColumn);
nullableEnumU64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU64AsStringCollectionColumn);
var nullableEnumU64CollectionColumn = new Column("NullableEnumU64Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU64Collection", nullableEnumU64CollectionColumn);
nullableEnumU64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU64CollectionColumn);
var nullableEnumU8Column = new Column("NullableEnumU8", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU8", nullableEnumU8Column);
nullableEnumU8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(nullableEnumU8Column);
var nullableEnumU8ArrayColumn = new Column("NullableEnumU8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU8Array", nullableEnumU8ArrayColumn);
nullableEnumU8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU8ArrayColumn);
var nullableEnumU8AsStringColumn = new Column("NullableEnumU8AsString", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableEnumU8AsString", nullableEnumU8AsStringColumn);
nullableEnumU8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(nullableEnumU8AsStringColumn);
var nullableEnumU8AsStringArrayColumn = new Column("NullableEnumU8AsStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU8AsStringArray", nullableEnumU8AsStringArrayColumn);
nullableEnumU8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU8AsStringArrayColumn);
var nullableEnumU8AsStringCollectionColumn = new Column("NullableEnumU8AsStringCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU8AsStringCollection", nullableEnumU8AsStringCollectionColumn);
nullableEnumU8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU8AsStringCollectionColumn);
var nullableEnumU8CollectionColumn = new Column("NullableEnumU8Collection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableEnumU8Collection", nullableEnumU8CollectionColumn);
nullableEnumU8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableEnumU8CollectionColumn);
var nullableFloatColumn = new Column("NullableFloat", "REAL", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableFloat", nullableFloatColumn);
nullableFloatColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<float>(nullableFloatColumn);
var nullableFloatArrayColumn = new Column("NullableFloatArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableFloatArray", nullableFloatArrayColumn);
nullableFloatArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableFloatArrayColumn);
var nullableGuidColumn = new Column("NullableGuid", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableGuid", nullableGuidColumn);
nullableGuidColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(nullableGuidColumn);
var nullableGuidArrayColumn = new Column("NullableGuidArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableGuidArray", nullableGuidArrayColumn);
nullableGuidArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableGuidArrayColumn);
var nullableIPAddressColumn = new Column("NullableIPAddress", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableIPAddress", nullableIPAddressColumn);
nullableIPAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableIPAddressColumn);
var nullableIPAddressArrayColumn = new Column("NullableIPAddressArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableIPAddressArray", nullableIPAddressArrayColumn);
nullableIPAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableIPAddressArrayColumn);
var nullableInt16Column = new Column("NullableInt16", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableInt16", nullableInt16Column);
nullableInt16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<short>(nullableInt16Column);
var nullableInt16ArrayColumn = new Column("NullableInt16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableInt16Array", nullableInt16ArrayColumn);
nullableInt16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableInt16ArrayColumn);
var nullableInt32Column = new Column("NullableInt32", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableInt32", nullableInt32Column);
nullableInt32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(nullableInt32Column);
var nullableInt32ArrayColumn = new Column("NullableInt32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableInt32Array", nullableInt32ArrayColumn);
nullableInt32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableInt32ArrayColumn);
var nullableInt64Column = new Column("NullableInt64", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableInt64", nullableInt64Column);
nullableInt64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(nullableInt64Column);
var nullableInt64ArrayColumn = new Column("NullableInt64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableInt64Array", nullableInt64ArrayColumn);
nullableInt64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableInt64ArrayColumn);
var nullableInt8Column = new Column("NullableInt8", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableInt8", nullableInt8Column);
nullableInt8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<sbyte>(nullableInt8Column);
var nullableInt8ArrayColumn = new Column("NullableInt8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableInt8Array", nullableInt8ArrayColumn);
nullableInt8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableInt8ArrayColumn);
var nullablePhysicalAddressColumn = new Column("NullablePhysicalAddress", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullablePhysicalAddress", nullablePhysicalAddressColumn);
nullablePhysicalAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullablePhysicalAddressColumn);
var nullablePhysicalAddressArrayColumn = new Column("NullablePhysicalAddressArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullablePhysicalAddressArray", nullablePhysicalAddressArrayColumn);
nullablePhysicalAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullablePhysicalAddressArrayColumn);
var nullableStringColumn = new Column("NullableString", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableString", nullableStringColumn);
nullableStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableStringColumn);
var nullableStringArrayColumn = new Column("NullableStringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableStringArray", nullableStringArrayColumn);
nullableStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableStringArrayColumn);
var nullableTimeOnlyColumn = new Column("NullableTimeOnly", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableTimeOnly", nullableTimeOnlyColumn);
nullableTimeOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<TimeOnly>(nullableTimeOnlyColumn);
var nullableTimeOnlyArrayColumn = new Column("NullableTimeOnlyArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableTimeOnlyArray", nullableTimeOnlyArrayColumn);
nullableTimeOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableTimeOnlyArrayColumn);
var nullableTimeSpanColumn = new Column("NullableTimeSpan", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableTimeSpan", nullableTimeSpanColumn);
nullableTimeSpanColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<TimeSpan>(nullableTimeSpanColumn);
var nullableTimeSpanArrayColumn = new Column("NullableTimeSpanArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableTimeSpanArray", nullableTimeSpanArrayColumn);
nullableTimeSpanArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableTimeSpanArrayColumn);
var nullableUInt16Column = new Column("NullableUInt16", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableUInt16", nullableUInt16Column);
nullableUInt16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ushort>(nullableUInt16Column);
var nullableUInt16ArrayColumn = new Column("NullableUInt16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableUInt16Array", nullableUInt16ArrayColumn);
nullableUInt16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableUInt16ArrayColumn);
var nullableUInt32Column = new Column("NullableUInt32", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableUInt32", nullableUInt32Column);
nullableUInt32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<uint>(nullableUInt32Column);
var nullableUInt32ArrayColumn = new Column("NullableUInt32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableUInt32Array", nullableUInt32ArrayColumn);
nullableUInt32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableUInt32ArrayColumn);
var nullableUInt64Column = new Column("NullableUInt64", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableUInt64", nullableUInt64Column);
nullableUInt64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ulong>(nullableUInt64Column);
var nullableUInt64ArrayColumn = new Column("NullableUInt64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableUInt64Array", nullableUInt64ArrayColumn);
nullableUInt64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableUInt64ArrayColumn);
var nullableUInt8Column = new Column("NullableUInt8", "INTEGER", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableUInt8", nullableUInt8Column);
nullableUInt8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(nullableUInt8Column);
var nullableUInt8ArrayColumn = new Column("NullableUInt8Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableUInt8Array", nullableUInt8ArrayColumn);
nullableUInt8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableUInt8ArrayColumn);
var nullableUriColumn = new Column("NullableUri", "TEXT", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("NullableUri", nullableUriColumn);
nullableUriColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableUriColumn);
var nullableUriArrayColumn = new Column("NullableUriArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("NullableUriArray", nullableUriArrayColumn);
nullableUriArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(nullableUriArrayColumn);
var physicalAddressColumn = new Column("PhysicalAddress", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("PhysicalAddress", physicalAddressColumn);
physicalAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(physicalAddressColumn);
var physicalAddressArrayColumn = new Column("PhysicalAddressArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("PhysicalAddressArray", physicalAddressArrayColumn);
physicalAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(physicalAddressArrayColumn);
var physicalAddressToBytesConverterPropertyColumn = new Column("PhysicalAddressToBytesConverterProperty", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("PhysicalAddressToBytesConverterProperty", physicalAddressToBytesConverterPropertyColumn);
physicalAddressToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(physicalAddressToBytesConverterPropertyColumn);
var physicalAddressToStringConverterPropertyColumn = new Column("PhysicalAddressToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("PhysicalAddressToStringConverterProperty", physicalAddressToStringConverterPropertyColumn);
physicalAddressToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(physicalAddressToStringConverterPropertyColumn);
var stringColumn = new Column("String", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("String", stringColumn);
stringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(stringColumn);
var stringArrayColumn = new Column("StringArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringArray", stringArrayColumn);
stringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(stringArrayColumn);
var stringReadOnlyCollectionColumn = new Column("StringReadOnlyCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringReadOnlyCollection", stringReadOnlyCollectionColumn);
stringReadOnlyCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(stringReadOnlyCollectionColumn);
var stringToBoolConverterPropertyColumn = new Column("StringToBoolConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("StringToBoolConverterProperty", stringToBoolConverterPropertyColumn);
stringToBoolConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<bool>(stringToBoolConverterPropertyColumn);
var stringToBytesConverterPropertyColumn = new Column("StringToBytesConverterProperty", "BLOB", manyTypesTable)
{
IsNullable = true
};
manyTypesTable.Columns.Add("StringToBytesConverterProperty", stringToBytesConverterPropertyColumn);
stringToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(stringToBytesConverterPropertyColumn);
var stringToCharConverterPropertyColumn = new Column("StringToCharConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToCharConverterProperty", stringToCharConverterPropertyColumn);
stringToCharConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<char>(stringToCharConverterPropertyColumn);
var stringToDateOnlyConverterPropertyColumn = new Column("StringToDateOnlyConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToDateOnlyConverterProperty", stringToDateOnlyConverterPropertyColumn);
stringToDateOnlyConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateOnly>(stringToDateOnlyConverterPropertyColumn);
var stringToDateTimeConverterPropertyColumn = new Column("StringToDateTimeConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToDateTimeConverterProperty", stringToDateTimeConverterPropertyColumn);
stringToDateTimeConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateTime>(stringToDateTimeConverterPropertyColumn);
var stringToDateTimeOffsetConverterPropertyColumn = new Column("StringToDateTimeOffsetConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToDateTimeOffsetConverterProperty", stringToDateTimeOffsetConverterPropertyColumn);
stringToDateTimeOffsetConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<DateTimeOffset>(stringToDateTimeOffsetConverterPropertyColumn);
var stringToDecimalNumberConverterPropertyColumn = new Column("StringToDecimalNumberConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToDecimalNumberConverterProperty", stringToDecimalNumberConverterPropertyColumn);
stringToDecimalNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<decimal>(stringToDecimalNumberConverterPropertyColumn);
var stringToDoubleNumberConverterPropertyColumn = new Column("StringToDoubleNumberConverterProperty", "REAL", manyTypesTable);
manyTypesTable.Columns.Add("StringToDoubleNumberConverterProperty", stringToDoubleNumberConverterPropertyColumn);
stringToDoubleNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<double>(stringToDoubleNumberConverterPropertyColumn);
var stringToEnumConverterPropertyColumn = new Column("StringToEnumConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("StringToEnumConverterProperty", stringToEnumConverterPropertyColumn);
stringToEnumConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<uint>(stringToEnumConverterPropertyColumn);
var stringToGuidConverterPropertyColumn = new Column("StringToGuidConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToGuidConverterProperty", stringToGuidConverterPropertyColumn);
stringToGuidConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(stringToGuidConverterPropertyColumn);
var stringToIntNumberConverterPropertyColumn = new Column("StringToIntNumberConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("StringToIntNumberConverterProperty", stringToIntNumberConverterPropertyColumn);
stringToIntNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(stringToIntNumberConverterPropertyColumn);
var stringToTimeOnlyConverterPropertyColumn = new Column("StringToTimeOnlyConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToTimeOnlyConverterProperty", stringToTimeOnlyConverterPropertyColumn);
stringToTimeOnlyConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<TimeOnly>(stringToTimeOnlyConverterPropertyColumn);
var stringToTimeSpanConverterPropertyColumn = new Column("StringToTimeSpanConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToTimeSpanConverterProperty", stringToTimeSpanConverterPropertyColumn);
stringToTimeSpanConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<TimeSpan>(stringToTimeSpanConverterPropertyColumn);
var stringToUriConverterPropertyColumn = new Column("StringToUriConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("StringToUriConverterProperty", stringToUriConverterPropertyColumn);
stringToUriConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(stringToUriConverterPropertyColumn);
var timeOnlyColumn = new Column("TimeOnly", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("TimeOnly", timeOnlyColumn);
timeOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<TimeOnly>(timeOnlyColumn);
var timeOnlyArrayColumn = new Column("TimeOnlyArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("TimeOnlyArray", timeOnlyArrayColumn);
timeOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(timeOnlyArrayColumn);
var timeOnlyToStringConverterPropertyColumn = new Column("TimeOnlyToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("TimeOnlyToStringConverterProperty", timeOnlyToStringConverterPropertyColumn);
timeOnlyToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(timeOnlyToStringConverterPropertyColumn);
var timeOnlyToTicksConverterPropertyColumn = new Column("TimeOnlyToTicksConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("TimeOnlyToTicksConverterProperty", timeOnlyToTicksConverterPropertyColumn);
timeOnlyToTicksConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(timeOnlyToTicksConverterPropertyColumn);
var timeSpanColumn = new Column("TimeSpan", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("TimeSpan", timeSpanColumn);
timeSpanColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<TimeSpan>(timeSpanColumn);
var timeSpanArrayColumn = new Column("TimeSpanArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("TimeSpanArray", timeSpanArrayColumn);
timeSpanArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(timeSpanArrayColumn);
var timeSpanToStringConverterPropertyColumn = new Column("TimeSpanToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("TimeSpanToStringConverterProperty", timeSpanToStringConverterPropertyColumn);
timeSpanToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(timeSpanToStringConverterPropertyColumn);
var timeSpanToTicksConverterPropertyColumn = new Column("TimeSpanToTicksConverterProperty", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("TimeSpanToTicksConverterProperty", timeSpanToTicksConverterPropertyColumn);
timeSpanToTicksConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(timeSpanToTicksConverterPropertyColumn);
var uInt16Column = new Column("UInt16", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("UInt16", uInt16Column);
uInt16Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ushort>(uInt16Column);
var uInt16ArrayColumn = new Column("UInt16Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("UInt16Array", uInt16ArrayColumn);
uInt16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uInt16ArrayColumn);
var uInt32Column = new Column("UInt32", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("UInt32", uInt32Column);
uInt32Column.Accessors = ColumnAccessorsFactory.CreateGeneric<uint>(uInt32Column);
var uInt32ArrayColumn = new Column("UInt32Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("UInt32Array", uInt32ArrayColumn);
uInt32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uInt32ArrayColumn);
var uInt64Column = new Column("UInt64", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("UInt64", uInt64Column);
uInt64Column.Accessors = ColumnAccessorsFactory.CreateGeneric<ulong>(uInt64Column);
var uInt64ArrayColumn = new Column("UInt64Array", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("UInt64Array", uInt64ArrayColumn);
uInt64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uInt64ArrayColumn);
var uInt8Column = new Column("UInt8", "INTEGER", manyTypesTable);
manyTypesTable.Columns.Add("UInt8", uInt8Column);
uInt8Column.Accessors = ColumnAccessorsFactory.CreateGeneric<byte>(uInt8Column);
var uInt8ArrayColumn = new Column("UInt8Array", "BLOB", manyTypesTable);
manyTypesTable.Columns.Add("UInt8Array", uInt8ArrayColumn);
uInt8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(uInt8ArrayColumn);
var uInt8ReadOnlyCollectionColumn = new Column("UInt8ReadOnlyCollection", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("UInt8ReadOnlyCollection", uInt8ReadOnlyCollectionColumn);
uInt8ReadOnlyCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uInt8ReadOnlyCollectionColumn);
var uriColumn = new Column("Uri", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("Uri", uriColumn);
uriColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uriColumn);
var uriArrayColumn = new Column("UriArray", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("UriArray", uriArrayColumn);
uriArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uriArrayColumn);
var uriToStringConverterPropertyColumn = new Column("UriToStringConverterProperty", "TEXT", manyTypesTable);
manyTypesTable.Columns.Add("UriToStringConverterProperty", uriToStringConverterPropertyColumn);
uriToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(uriToStringConverterPropertyColumn);
relationalModel.Tables.Add(("ManyTypes", null), manyTypesTable);
var manyTypesTableMapping = new TableMapping(manyTypes, manyTypesTable, null);
manyTypesTable.AddTypeMapping(manyTypesTableMapping, false);
tableMappings3.Add(manyTypesTableMapping);
RelationalModel.CreateColumnMapping(idColumn2, manyTypes.FindProperty("Id")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(boolColumn, manyTypes.FindProperty("Bool")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(boolArrayColumn, manyTypes.FindProperty("BoolArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(boolReadOnlyCollectionColumn, manyTypes.FindProperty("BoolReadOnlyCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(boolToStringConverterPropertyColumn, manyTypes.FindProperty("BoolToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(boolToTwoValuesConverterPropertyColumn, manyTypes.FindProperty("BoolToTwoValuesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(boolToZeroOneConverterPropertyColumn, manyTypes.FindProperty("BoolToZeroOneConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(bytesColumn, manyTypes.FindProperty("Bytes")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(bytesArrayColumn, manyTypes.FindProperty("BytesArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(bytesToStringConverterPropertyColumn, manyTypes.FindProperty("BytesToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(castingConverterPropertyColumn, manyTypes.FindProperty("CastingConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(charColumn, manyTypes.FindProperty("Char")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(charArrayColumn, manyTypes.FindProperty("CharArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(charToStringConverterPropertyColumn, manyTypes.FindProperty("CharToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateOnlyColumn, manyTypes.FindProperty("DateOnly")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateOnlyArrayColumn, manyTypes.FindProperty("DateOnlyArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateOnlyToStringConverterPropertyColumn, manyTypes.FindProperty("DateOnlyToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeColumn, manyTypes.FindProperty("DateTime")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeArrayColumn, manyTypes.FindProperty("DateTimeArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeOffsetToBinaryConverterPropertyColumn, manyTypes.FindProperty("DateTimeOffsetToBinaryConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeOffsetToBytesConverterPropertyColumn, manyTypes.FindProperty("DateTimeOffsetToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeOffsetToStringConverterPropertyColumn, manyTypes.FindProperty("DateTimeOffsetToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeToBinaryConverterPropertyColumn, manyTypes.FindProperty("DateTimeToBinaryConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeToStringConverterPropertyColumn, manyTypes.FindProperty("DateTimeToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(dateTimeToTicksConverterPropertyColumn, manyTypes.FindProperty("DateTimeToTicksConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(decimalColumn, manyTypes.FindProperty("Decimal")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(decimalArrayColumn, manyTypes.FindProperty("DecimalArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(decimalNumberToBytesConverterPropertyColumn, manyTypes.FindProperty("DecimalNumberToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(decimalNumberToStringConverterPropertyColumn, manyTypes.FindProperty("DecimalNumberToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(doubleColumn, manyTypes.FindProperty("Double")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(doubleArrayColumn, manyTypes.FindProperty("DoubleArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(doubleNumberToBytesConverterPropertyColumn, manyTypes.FindProperty("DoubleNumberToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(doubleNumberToStringConverterPropertyColumn, manyTypes.FindProperty("DoubleNumberToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum16Column, manyTypes.FindProperty("Enum16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum16ArrayColumn, manyTypes.FindProperty("Enum16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum16AsStringColumn, manyTypes.FindProperty("Enum16AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum16AsStringArrayColumn, manyTypes.FindProperty("Enum16AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum16AsStringCollectionColumn, manyTypes.FindProperty("Enum16AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum16CollectionColumn, manyTypes.FindProperty("Enum16Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum32Column, manyTypes.FindProperty("Enum32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum32ArrayColumn, manyTypes.FindProperty("Enum32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum32AsStringColumn, manyTypes.FindProperty("Enum32AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum32AsStringArrayColumn, manyTypes.FindProperty("Enum32AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum32AsStringCollectionColumn, manyTypes.FindProperty("Enum32AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum32CollectionColumn, manyTypes.FindProperty("Enum32Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum64Column, manyTypes.FindProperty("Enum64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum64ArrayColumn, manyTypes.FindProperty("Enum64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum64AsStringColumn, manyTypes.FindProperty("Enum64AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum64AsStringArrayColumn, manyTypes.FindProperty("Enum64AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum64AsStringCollectionColumn, manyTypes.FindProperty("Enum64AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum64CollectionColumn, manyTypes.FindProperty("Enum64Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum8Column, manyTypes.FindProperty("Enum8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum8ArrayColumn, manyTypes.FindProperty("Enum8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum8AsStringColumn, manyTypes.FindProperty("Enum8AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum8AsStringArrayColumn, manyTypes.FindProperty("Enum8AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum8AsStringCollectionColumn, manyTypes.FindProperty("Enum8AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enum8CollectionColumn, manyTypes.FindProperty("Enum8Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumToNumberConverterPropertyColumn, manyTypes.FindProperty("EnumToNumberConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumToStringConverterPropertyColumn, manyTypes.FindProperty("EnumToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU16Column, manyTypes.FindProperty("EnumU16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU16ArrayColumn, manyTypes.FindProperty("EnumU16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU16AsStringColumn, manyTypes.FindProperty("EnumU16AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU16AsStringArrayColumn, manyTypes.FindProperty("EnumU16AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU16AsStringCollectionColumn, manyTypes.FindProperty("EnumU16AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU16CollectionColumn, manyTypes.FindProperty("EnumU16Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU32Column, manyTypes.FindProperty("EnumU32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU32ArrayColumn, manyTypes.FindProperty("EnumU32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU32AsStringColumn, manyTypes.FindProperty("EnumU32AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU32AsStringArrayColumn, manyTypes.FindProperty("EnumU32AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU32AsStringCollectionColumn, manyTypes.FindProperty("EnumU32AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU32CollectionColumn, manyTypes.FindProperty("EnumU32Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU64Column, manyTypes.FindProperty("EnumU64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU64ArrayColumn, manyTypes.FindProperty("EnumU64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU64AsStringColumn, manyTypes.FindProperty("EnumU64AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU64AsStringArrayColumn, manyTypes.FindProperty("EnumU64AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU64AsStringCollectionColumn, manyTypes.FindProperty("EnumU64AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU64CollectionColumn, manyTypes.FindProperty("EnumU64Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU8Column, manyTypes.FindProperty("EnumU8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU8ArrayColumn, manyTypes.FindProperty("EnumU8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU8AsStringColumn, manyTypes.FindProperty("EnumU8AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU8AsStringArrayColumn, manyTypes.FindProperty("EnumU8AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU8AsStringCollectionColumn, manyTypes.FindProperty("EnumU8AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(enumU8CollectionColumn, manyTypes.FindProperty("EnumU8Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(floatColumn, manyTypes.FindProperty("Float")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(floatArrayColumn, manyTypes.FindProperty("FloatArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(guidColumn, manyTypes.FindProperty("Guid")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(guidArrayColumn, manyTypes.FindProperty("GuidArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(guidToBytesConverterPropertyColumn, manyTypes.FindProperty("GuidToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(guidToStringConverterPropertyColumn, manyTypes.FindProperty("GuidToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(iPAddressColumn, manyTypes.FindProperty("IPAddress")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(iPAddressArrayColumn, manyTypes.FindProperty("IPAddressArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(iPAddressReadOnlyCollectionColumn, manyTypes.FindProperty("IPAddressReadOnlyCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(iPAddressToBytesConverterPropertyColumn, manyTypes.FindProperty("IPAddressToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(iPAddressToStringConverterPropertyColumn, manyTypes.FindProperty("IPAddressToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int16Column, manyTypes.FindProperty("Int16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int16ArrayColumn, manyTypes.FindProperty("Int16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int32Column, manyTypes.FindProperty("Int32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int32ArrayColumn, manyTypes.FindProperty("Int32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int32ReadOnlyCollectionColumn, manyTypes.FindProperty("Int32ReadOnlyCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int64Column, manyTypes.FindProperty("Int64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int64ArrayColumn, manyTypes.FindProperty("Int64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int8Column, manyTypes.FindProperty("Int8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(int8ArrayColumn, manyTypes.FindProperty("Int8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(intNumberToBytesConverterPropertyColumn, manyTypes.FindProperty("IntNumberToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(intNumberToStringConverterPropertyColumn, manyTypes.FindProperty("IntNumberToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullIntToNullStringConverterPropertyColumn, manyTypes.FindProperty("NullIntToNullStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableBoolColumn, manyTypes.FindProperty("NullableBool")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableBoolArrayColumn, manyTypes.FindProperty("NullableBoolArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableBytesColumn, manyTypes.FindProperty("NullableBytes")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableBytesArrayColumn, manyTypes.FindProperty("NullableBytesArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableCharColumn, manyTypes.FindProperty("NullableChar")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableCharArrayColumn, manyTypes.FindProperty("NullableCharArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDateOnlyColumn, manyTypes.FindProperty("NullableDateOnly")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDateOnlyArrayColumn, manyTypes.FindProperty("NullableDateOnlyArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDateTimeColumn, manyTypes.FindProperty("NullableDateTime")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDateTimeArrayColumn, manyTypes.FindProperty("NullableDateTimeArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDecimalColumn, manyTypes.FindProperty("NullableDecimal")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDecimalArrayColumn, manyTypes.FindProperty("NullableDecimalArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDoubleColumn, manyTypes.FindProperty("NullableDouble")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableDoubleArrayColumn, manyTypes.FindProperty("NullableDoubleArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum16Column, manyTypes.FindProperty("NullableEnum16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum16ArrayColumn, manyTypes.FindProperty("NullableEnum16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum16AsStringColumn, manyTypes.FindProperty("NullableEnum16AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum16AsStringArrayColumn, manyTypes.FindProperty("NullableEnum16AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum16AsStringCollectionColumn, manyTypes.FindProperty("NullableEnum16AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum16CollectionColumn, manyTypes.FindProperty("NullableEnum16Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum32Column, manyTypes.FindProperty("NullableEnum32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum32ArrayColumn, manyTypes.FindProperty("NullableEnum32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum32AsStringColumn, manyTypes.FindProperty("NullableEnum32AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum32AsStringArrayColumn, manyTypes.FindProperty("NullableEnum32AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum32AsStringCollectionColumn, manyTypes.FindProperty("NullableEnum32AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum32CollectionColumn, manyTypes.FindProperty("NullableEnum32Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum64Column, manyTypes.FindProperty("NullableEnum64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum64ArrayColumn, manyTypes.FindProperty("NullableEnum64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum64AsStringColumn, manyTypes.FindProperty("NullableEnum64AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum64AsStringArrayColumn, manyTypes.FindProperty("NullableEnum64AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum64AsStringCollectionColumn, manyTypes.FindProperty("NullableEnum64AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum64CollectionColumn, manyTypes.FindProperty("NullableEnum64Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum8Column, manyTypes.FindProperty("NullableEnum8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum8ArrayColumn, manyTypes.FindProperty("NullableEnum8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum8AsStringColumn, manyTypes.FindProperty("NullableEnum8AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum8AsStringArrayColumn, manyTypes.FindProperty("NullableEnum8AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum8AsStringCollectionColumn, manyTypes.FindProperty("NullableEnum8AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnum8CollectionColumn, manyTypes.FindProperty("NullableEnum8Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU16Column, manyTypes.FindProperty("NullableEnumU16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU16ArrayColumn, manyTypes.FindProperty("NullableEnumU16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU16AsStringColumn, manyTypes.FindProperty("NullableEnumU16AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU16AsStringArrayColumn, manyTypes.FindProperty("NullableEnumU16AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU16AsStringCollectionColumn, manyTypes.FindProperty("NullableEnumU16AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU16CollectionColumn, manyTypes.FindProperty("NullableEnumU16Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU32Column, manyTypes.FindProperty("NullableEnumU32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU32ArrayColumn, manyTypes.FindProperty("NullableEnumU32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU32AsStringColumn, manyTypes.FindProperty("NullableEnumU32AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU32AsStringArrayColumn, manyTypes.FindProperty("NullableEnumU32AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU32AsStringCollectionColumn, manyTypes.FindProperty("NullableEnumU32AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU32CollectionColumn, manyTypes.FindProperty("NullableEnumU32Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU64Column, manyTypes.FindProperty("NullableEnumU64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU64ArrayColumn, manyTypes.FindProperty("NullableEnumU64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU64AsStringColumn, manyTypes.FindProperty("NullableEnumU64AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU64AsStringArrayColumn, manyTypes.FindProperty("NullableEnumU64AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU64AsStringCollectionColumn, manyTypes.FindProperty("NullableEnumU64AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU64CollectionColumn, manyTypes.FindProperty("NullableEnumU64Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU8Column, manyTypes.FindProperty("NullableEnumU8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU8ArrayColumn, manyTypes.FindProperty("NullableEnumU8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU8AsStringColumn, manyTypes.FindProperty("NullableEnumU8AsString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU8AsStringArrayColumn, manyTypes.FindProperty("NullableEnumU8AsStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU8AsStringCollectionColumn, manyTypes.FindProperty("NullableEnumU8AsStringCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableEnumU8CollectionColumn, manyTypes.FindProperty("NullableEnumU8Collection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableFloatColumn, manyTypes.FindProperty("NullableFloat")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableFloatArrayColumn, manyTypes.FindProperty("NullableFloatArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableGuidColumn, manyTypes.FindProperty("NullableGuid")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableGuidArrayColumn, manyTypes.FindProperty("NullableGuidArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableIPAddressColumn, manyTypes.FindProperty("NullableIPAddress")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableIPAddressArrayColumn, manyTypes.FindProperty("NullableIPAddressArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt16Column, manyTypes.FindProperty("NullableInt16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt16ArrayColumn, manyTypes.FindProperty("NullableInt16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt32Column, manyTypes.FindProperty("NullableInt32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt32ArrayColumn, manyTypes.FindProperty("NullableInt32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt64Column, manyTypes.FindProperty("NullableInt64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt64ArrayColumn, manyTypes.FindProperty("NullableInt64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt8Column, manyTypes.FindProperty("NullableInt8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableInt8ArrayColumn, manyTypes.FindProperty("NullableInt8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullablePhysicalAddressColumn, manyTypes.FindProperty("NullablePhysicalAddress")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullablePhysicalAddressArrayColumn, manyTypes.FindProperty("NullablePhysicalAddressArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableStringColumn, manyTypes.FindProperty("NullableString")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableStringArrayColumn, manyTypes.FindProperty("NullableStringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableTimeOnlyColumn, manyTypes.FindProperty("NullableTimeOnly")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableTimeOnlyArrayColumn, manyTypes.FindProperty("NullableTimeOnlyArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableTimeSpanColumn, manyTypes.FindProperty("NullableTimeSpan")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableTimeSpanArrayColumn, manyTypes.FindProperty("NullableTimeSpanArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt16Column, manyTypes.FindProperty("NullableUInt16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt16ArrayColumn, manyTypes.FindProperty("NullableUInt16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt32Column, manyTypes.FindProperty("NullableUInt32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt32ArrayColumn, manyTypes.FindProperty("NullableUInt32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt64Column, manyTypes.FindProperty("NullableUInt64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt64ArrayColumn, manyTypes.FindProperty("NullableUInt64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt8Column, manyTypes.FindProperty("NullableUInt8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUInt8ArrayColumn, manyTypes.FindProperty("NullableUInt8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUriColumn, manyTypes.FindProperty("NullableUri")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(nullableUriArrayColumn, manyTypes.FindProperty("NullableUriArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(physicalAddressColumn, manyTypes.FindProperty("PhysicalAddress")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(physicalAddressArrayColumn, manyTypes.FindProperty("PhysicalAddressArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(physicalAddressToBytesConverterPropertyColumn, manyTypes.FindProperty("PhysicalAddressToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(physicalAddressToStringConverterPropertyColumn, manyTypes.FindProperty("PhysicalAddressToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringColumn, manyTypes.FindProperty("String")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringArrayColumn, manyTypes.FindProperty("StringArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringReadOnlyCollectionColumn, manyTypes.FindProperty("StringReadOnlyCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToBoolConverterPropertyColumn, manyTypes.FindProperty("StringToBoolConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToBytesConverterPropertyColumn, manyTypes.FindProperty("StringToBytesConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToCharConverterPropertyColumn, manyTypes.FindProperty("StringToCharConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToDateOnlyConverterPropertyColumn, manyTypes.FindProperty("StringToDateOnlyConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToDateTimeConverterPropertyColumn, manyTypes.FindProperty("StringToDateTimeConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToDateTimeOffsetConverterPropertyColumn, manyTypes.FindProperty("StringToDateTimeOffsetConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToDecimalNumberConverterPropertyColumn, manyTypes.FindProperty("StringToDecimalNumberConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToDoubleNumberConverterPropertyColumn, manyTypes.FindProperty("StringToDoubleNumberConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToEnumConverterPropertyColumn, manyTypes.FindProperty("StringToEnumConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToGuidConverterPropertyColumn, manyTypes.FindProperty("StringToGuidConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToIntNumberConverterPropertyColumn, manyTypes.FindProperty("StringToIntNumberConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToTimeOnlyConverterPropertyColumn, manyTypes.FindProperty("StringToTimeOnlyConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToTimeSpanConverterPropertyColumn, manyTypes.FindProperty("StringToTimeSpanConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(stringToUriConverterPropertyColumn, manyTypes.FindProperty("StringToUriConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeOnlyColumn, manyTypes.FindProperty("TimeOnly")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeOnlyArrayColumn, manyTypes.FindProperty("TimeOnlyArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeOnlyToStringConverterPropertyColumn, manyTypes.FindProperty("TimeOnlyToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeOnlyToTicksConverterPropertyColumn, manyTypes.FindProperty("TimeOnlyToTicksConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeSpanColumn, manyTypes.FindProperty("TimeSpan")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeSpanArrayColumn, manyTypes.FindProperty("TimeSpanArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeSpanToStringConverterPropertyColumn, manyTypes.FindProperty("TimeSpanToStringConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(timeSpanToTicksConverterPropertyColumn, manyTypes.FindProperty("TimeSpanToTicksConverterProperty")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt16Column, manyTypes.FindProperty("UInt16")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt16ArrayColumn, manyTypes.FindProperty("UInt16Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt32Column, manyTypes.FindProperty("UInt32")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt32ArrayColumn, manyTypes.FindProperty("UInt32Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt64Column, manyTypes.FindProperty("UInt64")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt64ArrayColumn, manyTypes.FindProperty("UInt64Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt8Column, manyTypes.FindProperty("UInt8")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt8ArrayColumn, manyTypes.FindProperty("UInt8Array")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uInt8ReadOnlyCollectionColumn, manyTypes.FindProperty("UInt8ReadOnlyCollection")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uriColumn, manyTypes.FindProperty("Uri")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uriArrayColumn, manyTypes.FindProperty("UriArray")!, manyTypesTableMapping);
RelationalModel.CreateColumnMapping(uriToStringConverterPropertyColumn, manyTypes.FindProperty("UriToStringConverterProperty")!, manyTypesTableMapping);
var pK_ManyTypes = new UniqueConstraint("PK_ManyTypes", manyTypesTable, new[] { idColumn2 });
manyTypesTable.PrimaryKey = pK_ManyTypes;
pK_ManyTypes.SetRowKeyValueFactory(new SimpleRowKeyValueFactory<int>(pK_ManyTypes));
var pK_ManyTypesKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes",
new[] { "Id" });
pK_ManyTypes.MappedKeys.Add(pK_ManyTypesKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_ManyTypesKey).Add(pK_ManyTypes);
manyTypesTable.UniqueConstraints.Add("PK_ManyTypes", pK_ManyTypes);
var principalBase = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase")!;
var defaultTableMappings4 = new List<TableMappingBase<ColumnMappingBase>>();
principalBase.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings4);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", null, relationalModel);
var alternateIdColumnBase = new ColumnBase<ColumnMappingBase>("AlternateId", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("AlternateId", alternateIdColumnBase);
var detailsColumnBase = new ColumnBase<ColumnMappingBase>("Details", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Details", detailsColumnBase);
var enum1ColumnBase = new ColumnBase<ColumnMappingBase>("Enum1", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Enum1", enum1ColumnBase);
var enum2ColumnBase = new ColumnBase<ColumnMappingBase>("Enum2", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Enum2", enum2ColumnBase);
var flagsEnum1ColumnBase = new ColumnBase<ColumnMappingBase>("FlagsEnum1", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("FlagsEnum1", flagsEnum1ColumnBase);
var flagsEnum2ColumnBase = new ColumnBase<ColumnMappingBase>("FlagsEnum2", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("FlagsEnum2", flagsEnum2ColumnBase);
var idColumnBase3 = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Id", idColumnBase3);
var numberColumnBase = new ColumnBase<ColumnMappingBase>("Number", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Number", numberColumnBase);
var pointColumnBase0 = new ColumnBase<ColumnMappingBase>("Point", "geometry", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Point", pointColumnBase0);
var principalBaseAlternateIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalBaseAlternateId", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("PrincipalBaseAlternateId", principalBaseAlternateIdColumnBase);
var principalBaseIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalBaseId", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("PrincipalBaseId", principalBaseIdColumnBase);
var refTypeArrayColumnBase = new ColumnBase<ColumnMappingBase>("RefTypeArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeArray", refTypeArrayColumnBase);
var refTypeEnumerableColumnBase = new ColumnBase<ColumnMappingBase>("RefTypeEnumerable", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumnBase);
var refTypeIListColumnBase = new ColumnBase<ColumnMappingBase>("RefTypeIList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeIList", refTypeIListColumnBase);
var refTypeListColumnBase = new ColumnBase<ColumnMappingBase>("RefTypeList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeList", refTypeListColumnBase);
var valueTypeArrayColumnBase = new ColumnBase<ColumnMappingBase>("ValueTypeArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeArray", valueTypeArrayColumnBase);
var valueTypeEnumerableColumnBase = new ColumnBase<ColumnMappingBase>("ValueTypeEnumerable", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumnBase);
var valueTypeIListColumnBase = new ColumnBase<ColumnMappingBase>("ValueTypeIList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeIList", valueTypeIListColumnBase);
var valueTypeListColumnBase = new ColumnBase<ColumnMappingBase>("ValueTypeList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeList", valueTypeListColumnBase);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase = new TableMappingBase<ColumnMappingBase>(principalBase, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase, true);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase, false);
defaultTableMappings4.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)alternateIdColumnBase, principalBase.FindProperty("AlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase3, principalBase.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum1ColumnBase, principalBase.FindProperty("Enum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum2ColumnBase, principalBase.FindProperty("Enum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)flagsEnum1ColumnBase, principalBase.FindProperty("FlagsEnum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)flagsEnum2ColumnBase, principalBase.FindProperty("FlagsEnum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)pointColumnBase0, principalBase.FindProperty("Point")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeArrayColumnBase, principalBase.FindProperty("RefTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeEnumerableColumnBase, principalBase.FindProperty("RefTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeIListColumnBase, principalBase.FindProperty("RefTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeListColumnBase, principalBase.FindProperty("RefTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeArrayColumnBase, principalBase.FindProperty("ValueTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeEnumerableColumnBase, principalBase.FindProperty("ValueTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeIListColumnBase, principalBase.FindProperty("ValueTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeListColumnBase, principalBase.FindProperty("ValueTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase);
var tableMappings4 = new List<TableMapping>();
principalBase.SetRuntimeAnnotation("Relational:TableMappings", tableMappings4);
var principalBaseTable = new Table("PrincipalBase", "mySchema", relationalModel);
var idColumn3 = new Column("Id", "INTEGER", principalBaseTable);
principalBaseTable.Columns.Add("Id", idColumn3);
idColumn3.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(idColumn3);
var alternateIdColumn = new Column("AlternateId", "TEXT", principalBaseTable);
principalBaseTable.Columns.Add("AlternateId", alternateIdColumn);
alternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(alternateIdColumn);
var enum1Column = new Column("Enum1", "INTEGER", principalBaseTable);
principalBaseTable.Columns.Add("Enum1", enum1Column);
enum1Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(enum1Column);
var enum2Column = new Column("Enum2", "INTEGER", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Enum2", enum2Column);
enum2Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(enum2Column);
var flagsEnum1Column = new Column("FlagsEnum1", "INTEGER", principalBaseTable);
principalBaseTable.Columns.Add("FlagsEnum1", flagsEnum1Column);
flagsEnum1Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(flagsEnum1Column);
var flagsEnum2Column = new Column("FlagsEnum2", "INTEGER", principalBaseTable);
principalBaseTable.Columns.Add("FlagsEnum2", flagsEnum2Column);
flagsEnum2Column.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(flagsEnum2Column);
var owned_NumberColumn = new Column("Owned_Number", "INTEGER", principalBaseTable);
principalBaseTable.Columns.Add("Owned_Number", owned_NumberColumn);
owned_NumberColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(owned_NumberColumn);
var owned_RefTypeArrayColumn = new Column("Owned_RefTypeArray", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_RefTypeArray", owned_RefTypeArrayColumn);
owned_RefTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_RefTypeArrayColumn);
var owned_RefTypeEnumerableColumn = new Column("Owned_RefTypeEnumerable", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_RefTypeEnumerable", owned_RefTypeEnumerableColumn);
owned_RefTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_RefTypeEnumerableColumn);
var owned_RefTypeIListColumn = new Column("Owned_RefTypeIList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_RefTypeIList", owned_RefTypeIListColumn);
owned_RefTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_RefTypeIListColumn);
var owned_RefTypeListColumn = new Column("Owned_RefTypeList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_RefTypeList", owned_RefTypeListColumn);
owned_RefTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_RefTypeListColumn);
var owned_ValueTypeArrayColumn = new Column("Owned_ValueTypeArray", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_ValueTypeArray", owned_ValueTypeArrayColumn);
owned_ValueTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_ValueTypeArrayColumn);
var owned_ValueTypeEnumerableColumn = new Column("Owned_ValueTypeEnumerable", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_ValueTypeEnumerable", owned_ValueTypeEnumerableColumn);
owned_ValueTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_ValueTypeEnumerableColumn);
var owned_ValueTypeIListColumn = new Column("Owned_ValueTypeIList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_ValueTypeIList", owned_ValueTypeIListColumn);
owned_ValueTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_ValueTypeIListColumn);
var owned_ValueTypeListColumn = new Column("Owned_ValueTypeList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Owned_ValueTypeList", owned_ValueTypeListColumn);
owned_ValueTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(owned_ValueTypeListColumn);
var pointColumn0 = new Column("Point", "geometry", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("Point", pointColumn0);
pointColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<Point>(pointColumn0);
var refTypeArrayColumn = new Column("RefTypeArray", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("RefTypeArray", refTypeArrayColumn);
refTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeArrayColumn);
var refTypeEnumerableColumn = new Column("RefTypeEnumerable", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumn);
refTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeEnumerableColumn);
var refTypeIListColumn = new Column("RefTypeIList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("RefTypeIList", refTypeIListColumn);
refTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeIListColumn);
var refTypeListColumn = new Column("RefTypeList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("RefTypeList", refTypeListColumn);
refTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeListColumn);
var valueTypeArrayColumn = new Column("ValueTypeArray", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("ValueTypeArray", valueTypeArrayColumn);
valueTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeArrayColumn);
var valueTypeEnumerableColumn = new Column("ValueTypeEnumerable", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumn);
valueTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeEnumerableColumn);
var valueTypeIListColumn = new Column("ValueTypeIList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("ValueTypeIList", valueTypeIListColumn);
valueTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeIListColumn);
var valueTypeListColumn = new Column("ValueTypeList", "TEXT", principalBaseTable)
{
IsNullable = true
};
principalBaseTable.Columns.Add("ValueTypeList", valueTypeListColumn);
valueTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeListColumn);
relationalModel.Tables.Add(("PrincipalBase", "mySchema"), principalBaseTable);
var principalBaseTableMapping = new TableMapping(principalBase, principalBaseTable, true)
{
IsSharedTablePrincipal = true,
};
principalBaseTable.AddTypeMapping(principalBaseTableMapping, false);
tableMappings4.Add(principalBaseTableMapping);
RelationalModel.CreateColumnMapping(alternateIdColumn, principalBase.FindProperty("AlternateId")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(idColumn3, principalBase.FindProperty("Id")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(enum1Column, principalBase.FindProperty("Enum1")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(enum2Column, principalBase.FindProperty("Enum2")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(flagsEnum1Column, principalBase.FindProperty("FlagsEnum1")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(flagsEnum2Column, principalBase.FindProperty("FlagsEnum2")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(pointColumn0, principalBase.FindProperty("Point")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(refTypeArrayColumn, principalBase.FindProperty("RefTypeArray")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(refTypeEnumerableColumn, principalBase.FindProperty("RefTypeEnumerable")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(refTypeIListColumn, principalBase.FindProperty("RefTypeIList")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(refTypeListColumn, principalBase.FindProperty("RefTypeList")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(valueTypeArrayColumn, principalBase.FindProperty("ValueTypeArray")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn, principalBase.FindProperty("ValueTypeEnumerable")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(valueTypeIListColumn, principalBase.FindProperty("ValueTypeIList")!, principalBaseTableMapping);
RelationalModel.CreateColumnMapping(valueTypeListColumn, principalBase.FindProperty("ValueTypeList")!, principalBaseTableMapping);
var ownedType = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType")!;
var defaultTableMappings5 = new List<TableMappingBase<ColumnMappingBase>>();
ownedType.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings5);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0 = new TableMappingBase<ColumnMappingBase>(ownedType, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0, false);
defaultTableMappings5.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalBaseAlternateIdColumnBase, ownedType.FindProperty("PrincipalBaseAlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalBaseIdColumnBase, ownedType.FindProperty("PrincipalBaseId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)detailsColumnBase, ownedType.FindProperty("Details")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)numberColumnBase, ownedType.FindProperty("Number")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeArrayColumnBase, ownedType.FindProperty("RefTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeEnumerableColumnBase, ownedType.FindProperty("RefTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeIListColumnBase, ownedType.FindProperty("RefTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeListColumnBase, ownedType.FindProperty("RefTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeArrayColumnBase, ownedType.FindProperty("ValueTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeEnumerableColumnBase, ownedType.FindProperty("ValueTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeIListColumnBase, ownedType.FindProperty("ValueTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeListColumnBase, ownedType.FindProperty("ValueTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase0);
var tableMappings5 = new List<TableMapping>();
ownedType.SetRuntimeAnnotation("Relational:TableMappings", tableMappings5);
var principalBaseTableMapping0 = new TableMapping(ownedType, principalBaseTable, null)
{
IsSharedTablePrincipal = false,
IsSplitEntityTypePrincipal = true
};
principalBaseTable.AddTypeMapping(principalBaseTableMapping0, false);
tableMappings5.Add(principalBaseTableMapping0);
principalBaseTable.AddRowInternalForeignKey(ownedType, RelationalModel.GetForeignKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType",
new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "Id", "AlternateId" }));
RelationalModel.CreateColumnMapping(alternateIdColumn, ownedType.FindProperty("PrincipalBaseAlternateId")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(idColumn3, ownedType.FindProperty("PrincipalBaseId")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_NumberColumn, ownedType.FindProperty("Number")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_RefTypeArrayColumn, ownedType.FindProperty("RefTypeArray")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_RefTypeEnumerableColumn, ownedType.FindProperty("RefTypeEnumerable")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_RefTypeIListColumn, ownedType.FindProperty("RefTypeIList")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_RefTypeListColumn, ownedType.FindProperty("RefTypeList")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_ValueTypeArrayColumn, ownedType.FindProperty("ValueTypeArray")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_ValueTypeEnumerableColumn, ownedType.FindProperty("ValueTypeEnumerable")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_ValueTypeIListColumn, ownedType.FindProperty("ValueTypeIList")!, principalBaseTableMapping0);
RelationalModel.CreateColumnMapping(owned_ValueTypeListColumn, ownedType.FindProperty("ValueTypeList")!, principalBaseTableMapping0);
var detailsTable = new Table("Details", null, relationalModel);
var principalBaseIdColumn = new Column("PrincipalBaseId", "INTEGER", detailsTable);
detailsTable.Columns.Add("PrincipalBaseId", principalBaseIdColumn);
principalBaseIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(principalBaseIdColumn);
var principalBaseAlternateIdColumn = new Column("PrincipalBaseAlternateId", "TEXT", detailsTable);
detailsTable.Columns.Add("PrincipalBaseAlternateId", principalBaseAlternateIdColumn);
principalBaseAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(principalBaseAlternateIdColumn);
var detailsColumn = new Column("Details", "TEXT", detailsTable)
{
IsNullable = true
};
detailsTable.Columns.Add("Details", detailsColumn);
detailsColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(detailsColumn);
relationalModel.Tables.Add(("Details", null), detailsTable);
var detailsTableMapping = new TableMapping(ownedType, detailsTable, null)
{
IsSplitEntityTypePrincipal = false
};
detailsTable.AddTypeMapping(detailsTableMapping, false);
tableMappings5.Add(detailsTableMapping);
RelationalModel.CreateColumnMapping(principalBaseAlternateIdColumn, ownedType.FindProperty("PrincipalBaseAlternateId")!, detailsTableMapping);
RelationalModel.CreateColumnMapping(principalBaseIdColumn, ownedType.FindProperty("PrincipalBaseId")!, detailsTableMapping);
RelationalModel.CreateColumnMapping(detailsColumn, ownedType.FindProperty("Details")!, detailsTableMapping);
var pK_Details = new UniqueConstraint("PK_Details", detailsTable, new[] { principalBaseIdColumn, principalBaseAlternateIdColumn });
detailsTable.PrimaryKey = pK_Details;
pK_Details.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_Details));
var pK_DetailsKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType",
new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" });
pK_Details.MappedKeys.Add(pK_DetailsKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_DetailsKey).Add(pK_Details);
detailsTable.UniqueConstraints.Add("PK_Details", pK_Details);
var principalDerived = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>")!;
var defaultTableMappings6 = new List<TableMappingBase<ColumnMappingBase>>();
principalDerived.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings6);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1 = new TableMappingBase<ColumnMappingBase>(principalDerived, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1, false);
defaultTableMappings6.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)alternateIdColumnBase, principalDerived.FindProperty("AlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase3, principalDerived.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum1ColumnBase, principalDerived.FindProperty("Enum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)enum2ColumnBase, principalDerived.FindProperty("Enum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)flagsEnum1ColumnBase, principalDerived.FindProperty("FlagsEnum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)flagsEnum2ColumnBase, principalDerived.FindProperty("FlagsEnum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)pointColumnBase0, principalDerived.FindProperty("Point")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeArrayColumnBase, principalDerived.FindProperty("RefTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeEnumerableColumnBase, principalDerived.FindProperty("RefTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeIListColumnBase, principalDerived.FindProperty("RefTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeListColumnBase, principalDerived.FindProperty("RefTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeArrayColumnBase, principalDerived.FindProperty("ValueTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeEnumerableColumnBase, principalDerived.FindProperty("ValueTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeIListColumnBase, principalDerived.FindProperty("ValueTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeListColumnBase, principalDerived.FindProperty("ValueTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase1);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>", null, relationalModel);
var alternateIdColumnBase0 = new ColumnBase<ColumnMappingBase>("AlternateId", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("AlternateId", alternateIdColumnBase0);
var idColumnBase4 = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Id", idColumnBase4);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase = new TableMappingBase<ColumnMappingBase>(principalDerived, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase, false);
defaultTableMappings6.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)alternateIdColumnBase0, principalDerived.FindProperty("AlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase4, principalDerived.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase);
var tableMappings6 = new List<TableMapping>();
principalDerived.SetRuntimeAnnotation("Relational:TableMappings", tableMappings6);
var principalBaseTableMapping1 = new TableMapping(principalDerived, principalBaseTable, null)
{
IsSharedTablePrincipal = false,
};
principalBaseTable.AddTypeMapping(principalBaseTableMapping1, false);
tableMappings6.Add(principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(alternateIdColumn, principalDerived.FindProperty("AlternateId")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(idColumn3, principalDerived.FindProperty("Id")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(enum1Column, principalDerived.FindProperty("Enum1")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(enum2Column, principalDerived.FindProperty("Enum2")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(flagsEnum1Column, principalDerived.FindProperty("FlagsEnum1")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(flagsEnum2Column, principalDerived.FindProperty("FlagsEnum2")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(pointColumn0, principalDerived.FindProperty("Point")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(refTypeArrayColumn, principalDerived.FindProperty("RefTypeArray")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(refTypeEnumerableColumn, principalDerived.FindProperty("RefTypeEnumerable")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(refTypeIListColumn, principalDerived.FindProperty("RefTypeIList")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(refTypeListColumn, principalDerived.FindProperty("RefTypeList")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(valueTypeArrayColumn, principalDerived.FindProperty("ValueTypeArray")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn, principalDerived.FindProperty("ValueTypeEnumerable")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(valueTypeIListColumn, principalDerived.FindProperty("ValueTypeIList")!, principalBaseTableMapping1);
RelationalModel.CreateColumnMapping(valueTypeListColumn, principalDerived.FindProperty("ValueTypeList")!, principalBaseTableMapping1);
var aK_PrincipalBase_Id = new UniqueConstraint("AK_PrincipalBase_Id", principalBaseTable, new[] { idColumn3 });
aK_PrincipalBase_Id.SetRowKeyValueFactory(new SimpleRowKeyValueFactory<long>(aK_PrincipalBase_Id));
var aK_PrincipalBase_IdKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "Id" });
aK_PrincipalBase_Id.MappedKeys.Add(aK_PrincipalBase_IdKey);
RelationalModel.GetOrCreateUniqueConstraints(aK_PrincipalBase_IdKey).Add(aK_PrincipalBase_Id);
principalBaseTable.UniqueConstraints.Add("AK_PrincipalBase_Id", aK_PrincipalBase_Id);
var pK = new UniqueConstraint("PK", principalBaseTable, new[] { idColumn3, alternateIdColumn });
principalBaseTable.PrimaryKey = pK;
pK.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK));
var pKKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "Id", "AlternateId" });
pK.MappedKeys.Add(pKKey);
RelationalModel.GetOrCreateUniqueConstraints(pKKey).Add(pK);
pK.MappedKeys.Add(pK_DetailsKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_DetailsKey).Add(pK);
principalBaseTable.UniqueConstraints.Add("PK", pK);
var iX_PrincipalBase_AlternateId_Id = new TableIndex(
"IX_PrincipalBase_AlternateId_Id", principalBaseTable, new[] { alternateIdColumn, idColumn3 }, false);
iX_PrincipalBase_AlternateId_Id.SetRowIndexValueFactory(new CompositeRowIndexValueFactory(iX_PrincipalBase_AlternateId_Id));
var iX_PrincipalBase_AlternateId_IdIx = RelationalModel.GetIndex(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "AlternateId", "Id" });
iX_PrincipalBase_AlternateId_Id.MappedIndexes.Add(iX_PrincipalBase_AlternateId_IdIx);
RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_AlternateId_IdIx).Add(iX_PrincipalBase_AlternateId_Id);
principalBaseTable.Indexes.Add("IX_PrincipalBase_AlternateId_Id", iX_PrincipalBase_AlternateId_Id);
var principalDerivedTable = new Table("PrincipalDerived", null, relationalModel);
var derivedIdColumn = new Column("DerivedId", "INTEGER", principalDerivedTable);
principalDerivedTable.Columns.Add("DerivedId", derivedIdColumn);
derivedIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(derivedIdColumn);
var alternateIdColumn0 = new Column("AlternateId", "TEXT", principalDerivedTable);
principalDerivedTable.Columns.Add("AlternateId", alternateIdColumn0);
alternateIdColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(alternateIdColumn0);
relationalModel.Tables.Add(("PrincipalDerived", null), principalDerivedTable);
var principalDerivedTableMapping = new TableMapping(principalDerived, principalDerivedTable, null);
principalDerivedTable.AddTypeMapping(principalDerivedTableMapping, false);
tableMappings6.Add(principalDerivedTableMapping);
RelationalModel.CreateColumnMapping(alternateIdColumn0, principalDerived.FindProperty("AlternateId")!, principalDerivedTableMapping);
RelationalModel.CreateColumnMapping(derivedIdColumn, principalDerived.FindProperty("Id")!, principalDerivedTableMapping);
var aK_PrincipalDerived_DerivedId = new UniqueConstraint("AK_PrincipalDerived_DerivedId", principalDerivedTable, new[] { derivedIdColumn });
aK_PrincipalDerived_DerivedId.SetRowKeyValueFactory(new SimpleRowKeyValueFactory<long>(aK_PrincipalDerived_DerivedId));
aK_PrincipalDerived_DerivedId.MappedKeys.Add(aK_PrincipalBase_IdKey);
RelationalModel.GetOrCreateUniqueConstraints(aK_PrincipalBase_IdKey).Add(aK_PrincipalDerived_DerivedId);
principalDerivedTable.UniqueConstraints.Add("AK_PrincipalDerived_DerivedId", aK_PrincipalDerived_DerivedId);
var pK0 = new UniqueConstraint("PK", principalDerivedTable, new[] { derivedIdColumn, alternateIdColumn0 });
principalDerivedTable.PrimaryKey = pK0;
pK0.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK0));
pK0.MappedKeys.Add(pKKey);
RelationalModel.GetOrCreateUniqueConstraints(pKKey).Add(pK0);
principalDerivedTable.UniqueConstraints.Add("PK", pK0);
var iX_PrincipalDerived_AlternateId_DerivedId = new TableIndex(
"IX_PrincipalDerived_AlternateId_DerivedId", principalDerivedTable, new[] { alternateIdColumn0, derivedIdColumn }, false);
iX_PrincipalDerived_AlternateId_DerivedId.SetRowIndexValueFactory(new CompositeRowIndexValueFactory(iX_PrincipalDerived_AlternateId_DerivedId));
iX_PrincipalDerived_AlternateId_DerivedId.MappedIndexes.Add(iX_PrincipalBase_AlternateId_IdIx);
RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_AlternateId_IdIx).Add(iX_PrincipalDerived_AlternateId_DerivedId);
principalDerivedTable.Indexes.Add("IX_PrincipalDerived_AlternateId_DerivedId", iX_PrincipalDerived_AlternateId_DerivedId);
var ownedType0 = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>.ManyOwned#OwnedType")!;
var defaultTableMappings7 = new List<TableMappingBase<ColumnMappingBase>>();
ownedType0.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings7);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>.ManyOwned#OwnedType", null, relationalModel);
var detailsColumnBase0 = new ColumnBase<ColumnMappingBase>("Details", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("Details", detailsColumnBase0);
var idColumnBase5 = new ColumnBase<ColumnMappingBase>("Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("Id", idColumnBase5);
var numberColumnBase0 = new ColumnBase<ColumnMappingBase>("Number", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("Number", numberColumnBase0);
var principalDerivedDependentBasebyteAlternateIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalDerived<DependentBase<byte?>>AlternateId", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("PrincipalDerived<DependentBase<byte?>>AlternateId", principalDerivedDependentBasebyteAlternateIdColumnBase);
var principalDerivedDependentBasebyteIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalDerived<DependentBase<byte?>>Id", "INTEGER", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("PrincipalDerived<DependentBase<byte?>>Id", principalDerivedDependentBasebyteIdColumnBase);
var refTypeArrayColumnBase0 = new ColumnBase<ColumnMappingBase>("RefTypeArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("RefTypeArray", refTypeArrayColumnBase0);
var refTypeEnumerableColumnBase0 = new ColumnBase<ColumnMappingBase>("RefTypeEnumerable", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumnBase0);
var refTypeIListColumnBase0 = new ColumnBase<ColumnMappingBase>("RefTypeIList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("RefTypeIList", refTypeIListColumnBase0);
var refTypeListColumnBase0 = new ColumnBase<ColumnMappingBase>("RefTypeList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("RefTypeList", refTypeListColumnBase0);
var valueTypeArrayColumnBase0 = new ColumnBase<ColumnMappingBase>("ValueTypeArray", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("ValueTypeArray", valueTypeArrayColumnBase0);
var valueTypeEnumerableColumnBase0 = new ColumnBase<ColumnMappingBase>("ValueTypeEnumerable", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumnBase0);
var valueTypeIListColumnBase0 = new ColumnBase<ColumnMappingBase>("ValueTypeIList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("ValueTypeIList", valueTypeIListColumnBase0);
var valueTypeListColumnBase0 = new ColumnBase<ColumnMappingBase>("ValueTypeList", "TEXT", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase)
{
IsNullable = true
};
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.Columns.Add("ValueTypeList", valueTypeListColumnBase0);
relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>.ManyOwned#OwnedType", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase);
var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase = new TableMappingBase<ColumnMappingBase>(ownedType0, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase, null);
microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase, false);
defaultTableMappings7.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)idColumnBase5, ownedType0.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalDerivedDependentBasebyteAlternateIdColumnBase, ownedType0.FindProperty("PrincipalDerivedAlternateId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalDerivedDependentBasebyteIdColumnBase, ownedType0.FindProperty("PrincipalDerivedId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)detailsColumnBase0, ownedType0.FindProperty("Details")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)numberColumnBase0, ownedType0.FindProperty("Number")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeArrayColumnBase0, ownedType0.FindProperty("RefTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeEnumerableColumnBase0, ownedType0.FindProperty("RefTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeIListColumnBase0, ownedType0.FindProperty("RefTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)refTypeListColumnBase0, ownedType0.FindProperty("RefTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeArrayColumnBase0, ownedType0.FindProperty("ValueTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeEnumerableColumnBase0, ownedType0.FindProperty("ValueTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeIListColumnBase0, ownedType0.FindProperty("ValueTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)valueTypeListColumnBase0, ownedType0.FindProperty("ValueTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteManyOwnedOwnedTypeMappingBase);
var tableMappings7 = new List<TableMapping>();
ownedType0.SetRuntimeAnnotation("Relational:TableMappings", tableMappings7);
var manyOwnedTable = new Table("ManyOwned", null, relationalModel);
var principalDerivedDependentBasebyteIdColumn = new Column("PrincipalDerived<DependentBase<byte?>>Id", "INTEGER", manyOwnedTable);
manyOwnedTable.Columns.Add("PrincipalDerived<DependentBase<byte?>>Id", principalDerivedDependentBasebyteIdColumn);
principalDerivedDependentBasebyteIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(principalDerivedDependentBasebyteIdColumn);
var principalDerivedDependentBasebyteAlternateIdColumn = new Column("PrincipalDerived<DependentBase<byte?>>AlternateId", "TEXT", manyOwnedTable);
manyOwnedTable.Columns.Add("PrincipalDerived<DependentBase<byte?>>AlternateId", principalDerivedDependentBasebyteAlternateIdColumn);
principalDerivedDependentBasebyteAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(principalDerivedDependentBasebyteAlternateIdColumn);
var idColumn4 = new Column("Id", "INTEGER", manyOwnedTable);
manyOwnedTable.Columns.Add("Id", idColumn4);
idColumn4.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(idColumn4);
var detailsColumn0 = new Column("Details", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("Details", detailsColumn0);
detailsColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(detailsColumn0);
var numberColumn = new Column("Number", "INTEGER", manyOwnedTable);
manyOwnedTable.Columns.Add("Number", numberColumn);
numberColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<int>(numberColumn);
var refTypeArrayColumn0 = new Column("RefTypeArray", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("RefTypeArray", refTypeArrayColumn0);
refTypeArrayColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeArrayColumn0);
var refTypeEnumerableColumn0 = new Column("RefTypeEnumerable", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumn0);
refTypeEnumerableColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeEnumerableColumn0);
var refTypeIListColumn0 = new Column("RefTypeIList", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("RefTypeIList", refTypeIListColumn0);
refTypeIListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeIListColumn0);
var refTypeListColumn0 = new Column("RefTypeList", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("RefTypeList", refTypeListColumn0);
refTypeListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(refTypeListColumn0);
var valueTypeArrayColumn0 = new Column("ValueTypeArray", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("ValueTypeArray", valueTypeArrayColumn0);
valueTypeArrayColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeArrayColumn0);
var valueTypeEnumerableColumn0 = new Column("ValueTypeEnumerable", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumn0);
valueTypeEnumerableColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeEnumerableColumn0);
var valueTypeIListColumn0 = new Column("ValueTypeIList", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("ValueTypeIList", valueTypeIListColumn0);
valueTypeIListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeIListColumn0);
var valueTypeListColumn0 = new Column("ValueTypeList", "TEXT", manyOwnedTable)
{
IsNullable = true
};
manyOwnedTable.Columns.Add("ValueTypeList", valueTypeListColumn0);
valueTypeListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric<string>(valueTypeListColumn0);
relationalModel.Tables.Add(("ManyOwned", null), manyOwnedTable);
var manyOwnedTableMapping = new TableMapping(ownedType0, manyOwnedTable, null);
manyOwnedTable.AddTypeMapping(manyOwnedTableMapping, false);
tableMappings7.Add(manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(idColumn4, ownedType0.FindProperty("Id")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(principalDerivedDependentBasebyteAlternateIdColumn, ownedType0.FindProperty("PrincipalDerivedAlternateId")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(principalDerivedDependentBasebyteIdColumn, ownedType0.FindProperty("PrincipalDerivedId")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(detailsColumn0, ownedType0.FindProperty("Details")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(numberColumn, ownedType0.FindProperty("Number")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(refTypeArrayColumn0, ownedType0.FindProperty("RefTypeArray")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(refTypeEnumerableColumn0, ownedType0.FindProperty("RefTypeEnumerable")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(refTypeIListColumn0, ownedType0.FindProperty("RefTypeIList")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(refTypeListColumn0, ownedType0.FindProperty("RefTypeList")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(valueTypeArrayColumn0, ownedType0.FindProperty("ValueTypeArray")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn0, ownedType0.FindProperty("ValueTypeEnumerable")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(valueTypeIListColumn0, ownedType0.FindProperty("ValueTypeIList")!, manyOwnedTableMapping);
RelationalModel.CreateColumnMapping(valueTypeListColumn0, ownedType0.FindProperty("ValueTypeList")!, manyOwnedTableMapping);
var pK_ManyOwned = new UniqueConstraint("PK_ManyOwned", manyOwnedTable, new[] { principalDerivedDependentBasebyteIdColumn, principalDerivedDependentBasebyteAlternateIdColumn, idColumn4 });
manyOwnedTable.PrimaryKey = pK_ManyOwned;
pK_ManyOwned.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_ManyOwned));
var pK_ManyOwnedKey = RelationalModel.GetKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>.ManyOwned#OwnedType",
new[] { "PrincipalDerivedId", "PrincipalDerivedAlternateId", "Id" });
pK_ManyOwned.MappedKeys.Add(pK_ManyOwnedKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_ManyOwnedKey).Add(pK_ManyOwned);
manyOwnedTable.UniqueConstraints.Add("PK_ManyOwned", pK_ManyOwned);
var principalBasePrincipalDerivedDependentBasebyte = FindEntityType("PrincipalBasePrincipalDerived<DependentBase<byte?>>")!;
var defaultTableMappings8 = new List<TableMappingBase<ColumnMappingBase>>();
principalBasePrincipalDerivedDependentBasebyte.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings8);
var principalBasePrincipalDerivedDependentBasebyteTableBase = new TableBase("PrincipalBasePrincipalDerived<DependentBase<byte?>>", null, relationalModel);
var derivedsAlternateIdColumnBase = new ColumnBase<ColumnMappingBase>("DerivedsAlternateId", "TEXT", principalBasePrincipalDerivedDependentBasebyteTableBase);
principalBasePrincipalDerivedDependentBasebyteTableBase.Columns.Add("DerivedsAlternateId", derivedsAlternateIdColumnBase);
var derivedsIdColumnBase = new ColumnBase<ColumnMappingBase>("DerivedsId", "INTEGER", principalBasePrincipalDerivedDependentBasebyteTableBase);
principalBasePrincipalDerivedDependentBasebyteTableBase.Columns.Add("DerivedsId", derivedsIdColumnBase);
var principalsAlternateIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalsAlternateId", "TEXT", principalBasePrincipalDerivedDependentBasebyteTableBase);
principalBasePrincipalDerivedDependentBasebyteTableBase.Columns.Add("PrincipalsAlternateId", principalsAlternateIdColumnBase);
var principalsIdColumnBase = new ColumnBase<ColumnMappingBase>("PrincipalsId", "INTEGER", principalBasePrincipalDerivedDependentBasebyteTableBase);
principalBasePrincipalDerivedDependentBasebyteTableBase.Columns.Add("PrincipalsId", principalsIdColumnBase);
var rowidColumnBase = new ColumnBase<ColumnMappingBase>("rowid", "BLOB", principalBasePrincipalDerivedDependentBasebyteTableBase)
{
IsNullable = true
};
principalBasePrincipalDerivedDependentBasebyteTableBase.Columns.Add("rowid", rowidColumnBase);
relationalModel.DefaultTables.Add("PrincipalBasePrincipalDerived<DependentBase<byte?>>", principalBasePrincipalDerivedDependentBasebyteTableBase);
var principalBasePrincipalDerivedDependentBasebyteMappingBase = new TableMappingBase<ColumnMappingBase>(principalBasePrincipalDerivedDependentBasebyte, principalBasePrincipalDerivedDependentBasebyteTableBase, null);
principalBasePrincipalDerivedDependentBasebyteTableBase.AddTypeMapping(principalBasePrincipalDerivedDependentBasebyteMappingBase, false);
defaultTableMappings8.Add(principalBasePrincipalDerivedDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)derivedsAlternateIdColumnBase, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)derivedsIdColumnBase, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsId")!, principalBasePrincipalDerivedDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalsAlternateIdColumnBase, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)principalsIdColumnBase, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsId")!, principalBasePrincipalDerivedDependentBasebyteMappingBase);
RelationalModel.CreateColumnMapping((ColumnBase<ColumnMappingBase>)rowidColumnBase, principalBasePrincipalDerivedDependentBasebyte.FindProperty("rowid")!, principalBasePrincipalDerivedDependentBasebyteMappingBase);
var tableMappings8 = new List<TableMapping>();
principalBasePrincipalDerivedDependentBasebyte.SetRuntimeAnnotation("Relational:TableMappings", tableMappings8);
var principalBasePrincipalDerivedDependentBasebyteTable = new Table("PrincipalBasePrincipalDerived<DependentBase<byte?>>", null, relationalModel);
var derivedsIdColumn = new Column("DerivedsId", "INTEGER", principalBasePrincipalDerivedDependentBasebyteTable);
principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("DerivedsId", derivedsIdColumn);
derivedsIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(derivedsIdColumn);
var derivedsAlternateIdColumn = new Column("DerivedsAlternateId", "TEXT", principalBasePrincipalDerivedDependentBasebyteTable);
principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("DerivedsAlternateId", derivedsAlternateIdColumn);
derivedsAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(derivedsAlternateIdColumn);
var principalsIdColumn = new Column("PrincipalsId", "INTEGER", principalBasePrincipalDerivedDependentBasebyteTable);
principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("PrincipalsId", principalsIdColumn);
principalsIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<long>(principalsIdColumn);
var principalsAlternateIdColumn = new Column("PrincipalsAlternateId", "TEXT", principalBasePrincipalDerivedDependentBasebyteTable);
principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("PrincipalsAlternateId", principalsAlternateIdColumn);
principalsAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<Guid>(principalsAlternateIdColumn);
var rowidColumn = new Column("rowid", "BLOB", principalBasePrincipalDerivedDependentBasebyteTable)
{
IsNullable = true
};
principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("rowid", rowidColumn);
rowidColumn.Accessors = ColumnAccessorsFactory.CreateGeneric<byte[]>(rowidColumn);
relationalModel.Tables.Add(("PrincipalBasePrincipalDerived<DependentBase<byte?>>", null), principalBasePrincipalDerivedDependentBasebyteTable);
var principalBasePrincipalDerivedDependentBasebyteTableMapping = new TableMapping(principalBasePrincipalDerivedDependentBasebyte, principalBasePrincipalDerivedDependentBasebyteTable, null);
principalBasePrincipalDerivedDependentBasebyteTable.AddTypeMapping(principalBasePrincipalDerivedDependentBasebyteTableMapping, false);
tableMappings8.Add(principalBasePrincipalDerivedDependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(derivedsAlternateIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(derivedsIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(principalsAlternateIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(principalsIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping);
RelationalModel.CreateColumnMapping(rowidColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("rowid")!, principalBasePrincipalDerivedDependentBasebyteTableMapping);
var pK_PrincipalBasePrincipalDerivedDependentBasebyte = new UniqueConstraint("PK_PrincipalBasePrincipalDerived<DependentBase<byte?>>", principalBasePrincipalDerivedDependentBasebyteTable, new[] { derivedsIdColumn, derivedsAlternateIdColumn, principalsIdColumn, principalsAlternateIdColumn });
principalBasePrincipalDerivedDependentBasebyteTable.PrimaryKey = pK_PrincipalBasePrincipalDerivedDependentBasebyte;
pK_PrincipalBasePrincipalDerivedDependentBasebyte.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_PrincipalBasePrincipalDerivedDependentBasebyte));
var pK_PrincipalBasePrincipalDerivedDependentBasebyteKey = RelationalModel.GetKey(this,
"PrincipalBasePrincipalDerived<DependentBase<byte?>>",
new[] { "DerivedsId", "DerivedsAlternateId", "PrincipalsId", "PrincipalsAlternateId" });
pK_PrincipalBasePrincipalDerivedDependentBasebyte.MappedKeys.Add(pK_PrincipalBasePrincipalDerivedDependentBasebyteKey);
RelationalModel.GetOrCreateUniqueConstraints(pK_PrincipalBasePrincipalDerivedDependentBasebyteKey).Add(pK_PrincipalBasePrincipalDerivedDependentBasebyte);
principalBasePrincipalDerivedDependentBasebyteTable.UniqueConstraints.Add("PK_PrincipalBasePrincipalDerived<DependentBase<byte?>>", pK_PrincipalBasePrincipalDerivedDependentBasebyte);
var iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateId = new TableIndex(
"IX_PrincipalBasePrincipalDerived<DependentBase<byte?>>_PrincipalsId_PrincipalsAlternateId", principalBasePrincipalDerivedDependentBasebyteTable, new[] { principalsIdColumn, principalsAlternateIdColumn }, false);
iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateId.SetRowIndexValueFactory(new CompositeRowIndexValueFactory(iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateId));
var iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateIdIx = RelationalModel.GetIndex(this,
"PrincipalBasePrincipalDerived<DependentBase<byte?>>",
new[] { "PrincipalsId", "PrincipalsAlternateId" });
iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateId.MappedIndexes.Add(iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateIdIx);
RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateIdIx).Add(iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateId);
principalBasePrincipalDerivedDependentBasebyteTable.Indexes.Add("IX_PrincipalBasePrincipalDerived<DependentBase<byte?>>_PrincipalsId_PrincipalsAlternateId", iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalsId_PrincipalsAlternateId);
var fK_DependentBasebyte_PrincipalBase_PrincipalId = new ForeignKeyConstraint(
"FK_DependentBase<byte?>_PrincipalBase_PrincipalId", dependentBasebyteTable, principalBaseTable,
new[] { principalIdColumn },
principalBaseTable.FindUniqueConstraint("AK_PrincipalBase_Id")!, ReferentialAction.Cascade);
fK_DependentBasebyte_PrincipalBase_PrincipalId.SetRowForeignKeyValueFactory(RowForeignKeyValueFactoryFactory.CreateSimpleNonNullableFactory<long, long>(fK_DependentBasebyte_PrincipalBase_PrincipalId));
var fK_DependentBasebyte_PrincipalBase_PrincipalIdFk = RelationalModel.GetForeignKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>",
new[] { "PrincipalId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "Id" });
fK_DependentBasebyte_PrincipalBase_PrincipalId.MappedForeignKeys.Add(fK_DependentBasebyte_PrincipalBase_PrincipalIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_DependentBasebyte_PrincipalBase_PrincipalIdFk).Add(fK_DependentBasebyte_PrincipalBase_PrincipalId);
dependentBasebyteTable.ForeignKeyConstraints.Add(fK_DependentBasebyte_PrincipalBase_PrincipalId);
principalBaseTable.ReferencingForeignKeyConstraints.Add(fK_DependentBasebyte_PrincipalBase_PrincipalId);
var fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId = new ForeignKeyConstraint(
"FK_DependentBase<byte?>_PrincipalDerived_PrincipalId_PrincipalAlternateId", dependentBasebyteTable, principalDerivedTable,
new[] { principalIdColumn, principalAlternateIdColumn },
principalDerivedTable.FindUniqueConstraint("PK")!, ReferentialAction.NoAction);
fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId));
var fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateIdFk = RelationalModel.GetForeignKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>",
new[] { "PrincipalId", "PrincipalAlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>",
new[] { "Id", "AlternateId" });
fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId.MappedForeignKeys.Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateIdFk).Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId);
dependentBasebyteTable.ForeignKeyConstraints.Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId);
principalDerivedTable.ReferencingForeignKeyConstraints.Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAlternateId);
var fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId = new ForeignKeyConstraint(
"FK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId", detailsTable, principalBaseTable,
new[] { principalBaseIdColumn, principalBaseAlternateIdColumn },
principalBaseTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade);
fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId));
var fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateIdFk = RelationalModel.GetForeignKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType",
new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType",
new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" });
fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId.MappedForeignKeys.Add(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateIdFk).Add(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId);
detailsTable.ForeignKeyConstraints.Add(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId);
principalBaseTable.ReferencingForeignKeyConstraints.Add(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateId);
var fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId = new ForeignKeyConstraint(
"FK_ManyOwned_PrincipalDerived_PrincipalDerived<DependentBase<byte?>>Id_PrincipalDerived<DependentBase<byte?>>AlternateId", manyOwnedTable, principalDerivedTable,
new[] { principalDerivedDependentBasebyteIdColumn, principalDerivedDependentBasebyteAlternateIdColumn },
principalDerivedTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade);
fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId));
var fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateIdFk = RelationalModel.GetForeignKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>.ManyOwned#OwnedType",
new[] { "PrincipalDerivedId", "PrincipalDerivedAlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>",
new[] { "Id", "AlternateId" });
fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId.MappedForeignKeys.Add(fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateIdFk).Add(fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId);
manyOwnedTable.ForeignKeyConstraints.Add(fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId);
principalDerivedTable.ReferencingForeignKeyConstraints.Add(fK_ManyOwned_PrincipalDerived_PrincipalDerivedDependentBasebyteId_PrincipalDerivedDependentBasebyteAlternateId);
var fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId = new ForeignKeyConstraint(
"FK_PrincipalBasePrincipalDerived<DependentBase<byte?>>_PrincipalBase_PrincipalsId_PrincipalsAlternateId", principalBasePrincipalDerivedDependentBasebyteTable, principalBaseTable,
new[] { principalsIdColumn, principalsAlternateIdColumn },
principalBaseTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade);
fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId));
var fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateIdFk = RelationalModel.GetForeignKey(this,
"PrincipalBasePrincipalDerived<DependentBase<byte?>>",
new[] { "PrincipalsId", "PrincipalsAlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "Id", "AlternateId" });
fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId.MappedForeignKeys.Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateIdFk).Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId);
principalBasePrincipalDerivedDependentBasebyteTable.ForeignKeyConstraints.Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId);
principalBaseTable.ReferencingForeignKeyConstraints.Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalBase_PrincipalsId_PrincipalsAlternateId);
var fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId = new ForeignKeyConstraint(
"FK_PrincipalBasePrincipalDerived<DependentBase<byte?>>_PrincipalDerived_DerivedsId_DerivedsAlternateId", principalBasePrincipalDerivedDependentBasebyteTable, principalDerivedTable,
new[] { derivedsIdColumn, derivedsAlternateIdColumn },
principalDerivedTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade);
fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId));
var fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateIdFk = RelationalModel.GetForeignKey(this,
"PrincipalBasePrincipalDerived<DependentBase<byte?>>",
new[] { "DerivedsId", "DerivedsAlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>",
new[] { "Id", "AlternateId" });
fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId.MappedForeignKeys.Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateIdFk).Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId);
principalBasePrincipalDerivedDependentBasebyteTable.ForeignKeyConstraints.Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId);
principalDerivedTable.ReferencingForeignKeyConstraints.Add(fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipalDerived_DerivedsId_DerivedsAlternateId);
var fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId = new ForeignKeyConstraint(
"FK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId", principalDerivedTable, principalBaseTable,
new[] { derivedIdColumn, alternateIdColumn0 },
principalBaseTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade);
fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId));
var fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateIdFk = RelationalModel.GetForeignKey(this,
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived<Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase<byte?>>",
new[] { "Id", "AlternateId" },
"Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase",
new[] { "Id", "AlternateId" });
fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId.MappedForeignKeys.Add(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateIdFk);
RelationalModel.GetOrCreateForeignKeyConstraints(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateIdFk).Add(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId);
principalDerivedTable.ForeignKeyConstraints.Add(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId);
principalBaseTable.ReferencingForeignKeyConstraints.Add(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId);
return relationalModel.MakeReadOnly();
}
}
}
| DbContextModel |
csharp | AvaloniaUI__Avalonia | src/Avalonia.Base/Media/ImmediateDrawingContext.cs | {
"start": 219,
"end": 896
} | public sealed class ____ : IDisposable, IOptionalFeatureProvider
{
private readonly bool _ownsImpl;
private int _currentLevel;
private static ThreadSafeObjectPool<Stack<PushedState>> StateStackPool { get; } =
ThreadSafeObjectPool<Stack<PushedState>>.Default;
private static ThreadSafeObjectPool<Stack<TransformContainer>> TransformStackPool { get; } =
ThreadSafeObjectPool<Stack<TransformContainer>>.Default;
private Stack<PushedState>? _states = StateStackPool.Get();
private Stack<TransformContainer>? _transformContainers = TransformStackPool.Get();
readonly | ImmediateDrawingContext |
csharp | unoplatform__uno | src/Uno.UI/UI/Xaml/Media/PathSegmentCollection.cs | {
"start": 159,
"end": 418
} | public partial class ____ : DependencyObjectCollection<PathSegment>
{
public PathSegmentCollection()
{
}
private protected override void OnCollectionChanged()
{
base.OnCollectionChanged();
this.InvalidateMeasure();
}
}
}
| PathSegmentCollection |
csharp | pythonnet__pythonnet | src/runtime/StateSerialization/MaybeMethodBase.cs | {
"start": 244,
"end": 6662
} | internal struct ____<T> : ISerializable where T: MethodBase
{
// .ToString() of the serialized object
const string SerializationName = "s";
// The ReflectedType of the object
const string SerializationType = "t";
// Fhe parameters of the MethodBase
const string SerializationParameters = "p";
const string SerializationMethodName = "n";
const string SerializationGenericParamCount = "G";
const string SerializationFlags = "V";
public static implicit operator MaybeMethodBase<T> (T? ob) => new (ob);
readonly string? name;
readonly MethodBase? info;
[NonSerialized]
readonly Exception? deserializationException;
public string DeletedMessage
{
get
{
return $"The .NET {typeof(T)} {name} no longer exists. Cause: " + deserializationException?.Message ;
}
}
public T Value
{
get
{
if (info == null)
{
throw new SerializationException(DeletedMessage, innerException: deserializationException);
}
return (T)info;
}
}
public T UnsafeValue => (T)info!;
public string? Name => name;
[MemberNotNullWhen(true, nameof(info))]
public bool Valid => info != null;
public override string ToString()
{
return (info != null ? info.ToString() : $"missing method info: {name}");
}
public MaybeMethodBase(T? mi)
{
info = mi;
name = mi?.ToString();
Debug.Assert(name != null || info == null);
deserializationException = null;
}
internal MaybeMethodBase(SerializationInfo serializationInfo, StreamingContext context)
{
name = serializationInfo.GetString(SerializationName);
info = null;
deserializationException = null;
if (name is null) return;
try
{
// Retrieve the reflected type of the method;
var typeName = serializationInfo.GetString(SerializationType);
var tp = Type.GetType(typeName);
if (tp == null)
{
throw new SerializationException($"The underlying type {typeName} can't be found");
}
var flags = (MaybeMethodFlags)serializationInfo.GetInt32(SerializationFlags);
int genericCount = serializationInfo.GetInt32(SerializationGenericParamCount);
// Get the method's parameters types
var field_name = serializationInfo.GetString(SerializationMethodName);
var param = (ParameterHelper[])serializationInfo.GetValue(SerializationParameters, typeof(ParameterHelper[]));
info = ScanForMethod(tp, field_name, genericCount, flags, param);
}
catch (Exception e)
{
deserializationException = e;
}
}
static MethodBase ScanForMethod(Type declaringType, string name, int genericCount, MaybeMethodFlags flags, ParameterHelper[] parameters)
{
var bindingFlags = ClassManager.BindingFlags;
if (flags.HasFlag(MaybeMethodFlags.Constructor)) bindingFlags &= ~BindingFlags.Static;
var alternatives = declaringType.GetMember(name,
flags.HasFlag(MaybeMethodFlags.Constructor)
? MemberTypes.Constructor
: MemberTypes.Method,
bindingFlags);
if (alternatives.Length == 0)
throw new MissingMethodException($"{declaringType}.{name}");
var visibility = flags & MaybeMethodFlags.Visibility;
var result = alternatives.Cast<MethodBase>().FirstOrDefault(m
=> MatchesGenericCount(m, genericCount) && MatchesSignature(m, parameters)
&& (Visibility(m) == visibility || ClassManager.ShouldBindMethod(m)));
if (result is null)
throw new MissingMethodException($"Matching overload not found for {declaringType}.{name}");
return result;
}
static bool MatchesGenericCount(MethodBase method, int genericCount)
=> method.ContainsGenericParameters
? method.GetGenericArguments().Length == genericCount
: genericCount == 0;
static bool MatchesSignature(MethodBase method, ParameterHelper[] parameters)
{
var curr = method.GetParameters();
if (curr.Length != parameters.Length) return false;
for (int i = 0; i < curr.Length; i++)
if (!parameters[i].Matches(curr[i])) return false;
return true;
}
public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
{
serializationInfo.AddValue(SerializationName, name);
if (Valid)
{
serializationInfo.AddValue(SerializationMethodName, info.Name);
serializationInfo.AddValue(SerializationGenericParamCount,
info.ContainsGenericParameters ? info.GetGenericArguments().Length : 0);
serializationInfo.AddValue(SerializationFlags, (int)Flags(info));
string? typeName = info.ReflectedType.AssemblyQualifiedName;
Debug.Assert(typeName != null);
serializationInfo.AddValue(SerializationType, typeName);
ParameterHelper[] parameters = (from p in info.GetParameters() select new ParameterHelper(p)).ToArray();
serializationInfo.AddValue(SerializationParameters, parameters, typeof(ParameterHelper[]));
}
}
static MaybeMethodFlags Flags(MethodBase method)
{
var flags = MaybeMethodFlags.Default;
if (method.IsConstructor) flags |= MaybeMethodFlags.Constructor;
if (method.IsStatic) flags |= MaybeMethodFlags.Static;
if (method.IsPublic) flags |= MaybeMethodFlags.Public;
return flags;
}
static MaybeMethodFlags Visibility(MethodBase method)
=> Flags(method) & MaybeMethodFlags.Visibility;
}
[Flags]
| MaybeMethodBase |
csharp | dotnet__aspire | src/Aspire.Hosting/IInteractionService.cs | {
"start": 669,
"end": 5866
} | public interface ____
{
/// <summary>
/// Gets a value indicating whether the interaction service is available. If <c>false</c>,
/// this service is not available to interact with the user and service methods will throw
/// an exception.
/// </summary>
bool IsAvailable { get; }
/// <summary>
/// Prompts the user for confirmation with a dialog.
/// </summary>
/// <param name="title">The title of the dialog.</param>
/// <param name="message">The message to display in the dialog.</param>
/// <param name="options">Optional configuration for the message box interaction.</param>
/// <param name="cancellationToken">A token to cancel the operation.</param>
/// <returns>
/// An <see cref="InteractionResult{T}"/> containing <c>true</c> if the user confirmed, <c>false</c> otherwise.
/// </returns>
Task<InteractionResult<bool>> PromptConfirmationAsync(string title, string message, MessageBoxInteractionOptions? options = null, CancellationToken cancellationToken = default);
/// <summary>
/// Prompts the user with a message box dialog.
/// </summary>
/// <param name="title">The title of the message box.</param>
/// <param name="message">The message to display in the message box.</param>
/// <param name="options">Optional configuration for the message box interaction.</param>
/// <param name="cancellationToken">A token to cancel the operation.</param>
/// <returns>
/// An <see cref="InteractionResult{T}"/> containing <c>true</c> if the user accepted, <c>false</c> otherwise.
/// </returns>
Task<InteractionResult<bool>> PromptMessageBoxAsync(string title, string message, MessageBoxInteractionOptions? options = null, CancellationToken cancellationToken = default);
/// <summary>
/// Prompts the user for a single text input.
/// </summary>
/// <param name="title">The title of the input dialog.</param>
/// <param name="message">The message to display in the dialog.</param>
/// <param name="inputLabel">The label for the input field.</param>
/// <param name="placeHolder">The placeholder text for the input field.</param>
/// <param name="options">Optional configuration for the input dialog interaction.</param>
/// <param name="cancellationToken">A token to cancel the operation.</param>
/// <returns>
/// An <see cref="InteractionResult{T}"/> containing the user's input.
/// </returns>
Task<InteractionResult<InteractionInput>> PromptInputAsync(string title, string? message, string inputLabel, string placeHolder, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default);
/// <summary>
/// Prompts the user for a single input using a specified <see cref="InteractionInput"/>.
/// </summary>
/// <param name="title">The title of the input dialog.</param>
/// <param name="message">The message to display in the dialog.</param>
/// <param name="input">The input configuration.</param>
/// <param name="options">Optional configuration for the input dialog interaction.</param>
/// <param name="cancellationToken">A token to cancel the operation.</param>
/// <returns>
/// An <see cref="InteractionResult{T}"/> containing the user's input.
/// </returns>
Task<InteractionResult<InteractionInput>> PromptInputAsync(string title, string? message, InteractionInput input, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default);
/// <summary>
/// Prompts the user for multiple inputs.
/// </summary>
/// <param name="title">The title of the input dialog.</param>
/// <param name="message">The message to display in the dialog.</param>
/// <param name="inputs">A collection of <see cref="InteractionInput"/> to prompt for.</param>
/// <param name="options">Optional configuration for the input dialog interaction.</param>
/// <param name="cancellationToken">A token to cancel the operation.</param>
/// <returns>
/// An <see cref="InteractionResult{T}"/> containing the user's inputs as an <see cref="InteractionInputCollection"/>.
/// </returns>
Task<InteractionResult<InteractionInputCollection>> PromptInputsAsync(string title, string? message, IReadOnlyList<InteractionInput> inputs, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default);
/// <summary>
/// Prompts the user with a notification.
/// </summary>
/// <param name="title">The title of the notification.</param>
/// <param name="message">The message to display in the notification.</param>
/// <param name="options">Optional configuration for the notification interaction.</param>
/// <param name="cancellationToken">A token to cancel the operation.</param>
/// <returns>
/// An <see cref="InteractionResult{T}"/> containing <c>true</c> if the user accepted, <c>false</c> otherwise.
/// </returns>
Task<InteractionResult<bool>> PromptNotificationAsync(string title, string message, NotificationInteractionOptions? options = null, CancellationToken cancellationToken = default);
}
| IInteractionService |
csharp | fluentassertions__fluentassertions | Src/FluentAssertions/Equivalency/Ordering/CollectionMemberObjectInfo.cs | {
"start": 65,
"end": 844
} | internal class ____ : IObjectInfo
{
public CollectionMemberObjectInfo(IObjectInfo context)
{
Path = GetAdjustedPropertyPath(context.Path);
#pragma warning disable CS0618
Type = context.Type;
#pragma warning restore CS0618
ParentType = context.ParentType;
RuntimeType = context.RuntimeType;
CompileTimeType = context.CompileTimeType;
}
private static string GetAdjustedPropertyPath(string propertyPath)
{
return propertyPath.Substring(propertyPath.IndexOf('.', StringComparison.Ordinal) + 1);
}
public Type Type { get; }
public Type ParentType { get; }
public string Path { get; set; }
public Type CompileTimeType { get; }
public Type RuntimeType { get; }
}
| CollectionMemberObjectInfo |
csharp | dotnet__reactive | Rx.NET/Source/src/System.Reactive/Linq/Observable/Sum.cs | {
"start": 7415,
"end": 7841
} | internal sealed class ____ : Producer<decimal?, SumDecimalNullable._>
{
private readonly IObservable<decimal?> _source;
public SumDecimalNullable(IObservable<decimal?> source)
{
_source = source;
}
protected override _ CreateSink(IObserver<decimal?> observer) => new(observer);
protected override void Run(_ sink) => sink.Run(_source);
| SumDecimalNullable |
csharp | moq__moq4 | src/Moq.Tests/ReflectionExtensions.cs | {
"start": 267,
"end": 565
} | public static class ____
{
public static IEnumerable<MethodInfo> GetAccessors(this EventInfo @event, bool nonPublic = false)
{
yield return @event.GetAddMethod(nonPublic);
yield return @event.GetRemoveMethod(nonPublic);
}
}
}
| ReflectionExtensions |
csharp | protobuf-net__protobuf-net | src/protobuf-net.Test/CustomSerializers.cs | {
"start": 128,
"end": 2003
} | public class ____
{
[Fact]
public void CustomSerializerDetectedOnModel()
{
var model = RuntimeTypeModel.Create();
model.AutoCompile = false;
model.Add<HazCustomSerializer>();
model.Add<HazIndirectCustomSerializer>();
var rt = model[typeof(HazCustomSerializer)];
Assert.Equal(typeof(CustomSerializer), rt.SerializerType);
// detected on runtime model
Test(model);
// detected on runtime model (compiled)
model.CompileInPlace();
Test(model);
// detected on fully compiled model (and check IL)
var compiled = model.CompileAndVerify();
Test(compiled);
// detected on in-process compiled model
compiled = model.Compile();
Test(compiled);
static void Test(TypeModel model)
{
object obj = model.GetSerializerCore<HazCustomSerializer>(default);
Assert.IsType<CustomSerializer>(obj);
obj = model.GetSerializerCore<HazIndirectCustomSerializer>(default);
Assert.IsType<IndirectSerializer>(obj);
}
}
[Fact]
public void CustomSerializerWorks()
{
var obj = new HazCustomSerializer { Inner = { Name = nameof(CustomSerializerWorks) } };
Assert.Equal(CustomSerializerOperations.None, obj.ViaCustomSerializer);
var clone = Serializer.DeepClone(obj);
Assert.NotSame(obj, clone);
Assert.Equal(CustomSerializerOperations.Write, obj.ViaCustomSerializer);
Assert.Equal(CustomSerializerOperations.Read, clone.ViaCustomSerializer);
Assert.Equal(nameof(CustomSerializerWorks), clone.Inner.Name);
}
[Flags]
| CustomSerializers |
csharp | unoplatform__uno | src/Uno.UWP/Generated/3.0.0.0/Windows.Graphics.Printing.OptionDetails/PrintCustomItemListOptionDetails.cs | {
"start": 314,
"end": 10856
} | public partial class ____ : global::Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails, global::Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails, global::Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
internal PrintCustomItemListOptionDetails()
{
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public string WarningText
{
get
{
throw new global::System.NotImplementedException("The member string PrintCustomItemListOptionDetails.WarningText is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=string%20PrintCustomItemListOptionDetails.WarningText");
}
set
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "string PrintCustomItemListOptionDetails.WarningText");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public string Description
{
get
{
throw new global::System.NotImplementedException("The member string PrintCustomItemListOptionDetails.Description is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=string%20PrintCustomItemListOptionDetails.Description");
}
set
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "string PrintCustomItemListOptionDetails.Description");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public string DisplayName
{
get
{
throw new global::System.NotImplementedException("The member string PrintCustomItemListOptionDetails.DisplayName is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=string%20PrintCustomItemListOptionDetails.DisplayName");
}
set
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "string PrintCustomItemListOptionDetails.DisplayName");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::System.Collections.Generic.IReadOnlyList<object> Items
{
get
{
throw new global::System.NotImplementedException("The member IReadOnlyList<object> PrintCustomItemListOptionDetails.Items is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=IReadOnlyList%3Cobject%3E%20PrintCustomItemListOptionDetails.Items");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::Windows.Graphics.Printing.OptionDetails.PrintOptionStates State
{
get
{
throw new global::System.NotImplementedException("The member PrintOptionStates PrintCustomItemListOptionDetails.State is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=PrintOptionStates%20PrintCustomItemListOptionDetails.State");
}
set
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "PrintOptionStates PrintCustomItemListOptionDetails.State");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public string ErrorText
{
get
{
throw new global::System.NotImplementedException("The member string PrintCustomItemListOptionDetails.ErrorText is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=string%20PrintCustomItemListOptionDetails.ErrorText");
}
set
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "string PrintCustomItemListOptionDetails.ErrorText");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public string OptionId
{
get
{
throw new global::System.NotImplementedException("The member string PrintCustomItemListOptionDetails.OptionId is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=string%20PrintCustomItemListOptionDetails.OptionId");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::Windows.Graphics.Printing.OptionDetails.PrintOptionType OptionType
{
get
{
throw new global::System.NotImplementedException("The member PrintOptionType PrintCustomItemListOptionDetails.OptionType is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=PrintOptionType%20PrintCustomItemListOptionDetails.OptionType");
}
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public object Value
{
get
{
throw new global::System.NotImplementedException("The member object PrintCustomItemListOptionDetails.Value is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=object%20PrintCustomItemListOptionDetails.Value");
}
}
#endif
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.OptionId.get
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.OptionType.get
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.ErrorText.set
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.ErrorText.get
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.State.set
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.State.get
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.Value.get
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public bool TrySetValue(object value)
{
throw new global::System.NotImplementedException("The member bool PrintCustomItemListOptionDetails.TrySetValue(object value) is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=bool%20PrintCustomItemListOptionDetails.TrySetValue%28object%20value%29");
}
#endif
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.DisplayName.set
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.DisplayName.get
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.Items.get
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public void AddItem(string itemId, string displayName)
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "void PrintCustomItemListOptionDetails.AddItem(string itemId, string displayName)");
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public void AddItem(string itemId, string displayName, string description, global::Windows.Storage.Streams.IRandomAccessStreamWithContentType icon)
{
global::Windows.Foundation.Metadata.ApiInformation.TryRaiseNotImplemented("Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails", "void PrintCustomItemListOptionDetails.AddItem(string itemId, string displayName, string description, IRandomAccessStreamWithContentType icon)");
}
#endif
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.WarningText.set
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.WarningText.get
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.Description.set
// Forced skipping of method Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails.Description.get
// Processing: Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails
// Processing: Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails
// Processing: Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails
}
}
| PrintCustomItemListOptionDetails |
csharp | protobuf-net__protobuf-net | src/Examples/EnumTests.cs | {
"start": 560,
"end": 638
} | enum ____
{
A = -1, B = 0, C = 1
}
[ProtoContract]
| NegEnum |
csharp | fluentassertions__fluentassertions | Src/FluentAssertions/Types/TypeAssertions.cs | {
"start": 62627,
"end": 95835
} | interface ____ member is not being explicitly implemented.</typeparam>
/// <param name="name">The name of the method.</param>
/// <param name="parameterTypes">The expected types of the method parameters.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndConstraint<TypeAssertions> NotHaveExplicitMethod<TInterface>(
string name, IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
where TInterface : class
{
return NotHaveExplicitMethod(typeof(TInterface), name, parameterTypes, because, becauseArgs);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has an indexer of type <paramref name="indexerType"/>.
/// with parameter types <paramref name="parameterTypes"/>.
/// </summary>
/// <param name="indexerType">The type of the indexer.</param>
/// <param name="parameterTypes">The parameter types for the indexer.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="indexerType"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveIndexer(
Type indexerType, IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(indexerType);
Guard.ThrowIfArgumentIsNull(parameterTypes);
string parameterString = GetParameterString(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith(
$"Expected {indexerType.Name} {{context:type}}[{parameterString}] to exist{{reason}}" +
", but {context:type} is <null>.");
PropertyInfo propertyInfo = null;
if (assertionChain.Succeeded)
{
propertyInfo = Subject.GetIndexerByParameterTypes(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(propertyInfo is not null)
.FailWith(
$"Expected {indexerType.Name} {Subject}[{parameterString}] to exist{{reason}}" +
", but it does not.")
.Then
.ForCondition(propertyInfo.PropertyType == indexerType)
.FailWith("Expected {0} to be of type {1}{reason}, but it is not.", propertyInfo, indexerType);
}
return new AndWhichConstraint<TypeAssertions, PropertyInfo>(this, propertyInfo, assertionChain,
$"[{parameterString}]");
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have an indexer that takes parameter types
/// <paramref name="parameterTypes"/>.
/// </summary>
/// <param name="parameterTypes">The expected indexer's parameter types.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndConstraint<TypeAssertions> NotHaveIndexer(
IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith(
$"Expected indexer {{context:type}}[{GetParameterString(parameterTypes)}] to not exist{{reason}}" +
", but {context:type} is <null>.");
if (assertionChain.Succeeded)
{
PropertyInfo propertyInfo = Subject.GetIndexerByParameterTypes(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(propertyInfo is null)
.FailWith(
$"Expected indexer {Subject}[{GetParameterString(parameterTypes)}] to not exist{{reason}}" +
", but it does.");
}
return new AndConstraint<TypeAssertions>(this);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has a method named <paramref name="name"/> with parameter types
/// <paramref name="parameterTypes"/>.
/// </summary>
/// <param name="name">The name of the method.</param>
/// <param name="parameterTypes">The parameter types for the indexer.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndWhichConstraint<TypeAssertions, MethodInfo> HaveMethod(
string name, IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNullOrEmpty(name);
Guard.ThrowIfArgumentIsNull(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith(
$"Expected method {{context:type}}.{name}({GetParameterString(parameterTypes)}) to exist{{reason}}" +
", but {context:type} is <null>.");
MethodInfo methodInfo = null;
if (assertionChain.Succeeded)
{
methodInfo = Subject.GetMethod(name, parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(methodInfo is not null)
.FailWith(
$"Expected method {Subject}.{name}({GetParameterString(parameterTypes)}) to exist{{reason}}" +
", but it does not.");
}
return new AndWhichConstraint<TypeAssertions, MethodInfo>(this, methodInfo);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not expose a method named <paramref name="name"/>
/// with parameter types <paramref name="parameterTypes"/>.
/// </summary>
/// <param name="name">The name of the method.</param>
/// <param name="parameterTypes">The method parameter types.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndConstraint<TypeAssertions> NotHaveMethod(
string name, IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNullOrEmpty(name);
Guard.ThrowIfArgumentIsNull(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith(
$"Expected method {{context:type}}.{name}({GetParameterString(parameterTypes)}) to not exist{{reason}}" +
", but {context:type} is <null>.");
if (assertionChain.Succeeded)
{
MethodInfo methodInfo = Subject.GetMethod(name, parameterTypes);
var methodInfoDescription = MethodInfoAssertions.GetDescriptionFor(methodInfo);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(methodInfo is null)
.FailWith(
$"Expected method {methodInfoDescription}({GetParameterString(parameterTypes)}) to not exist{{reason}}" +
", but it does.");
}
return new AndConstraint<TypeAssertions>(this);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has a constructor with <paramref name="parameterTypes"/>.
/// </summary>
/// <param name="parameterTypes">The parameter types for the indexer.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndWhichConstraint<TypeAssertions, ConstructorInfo> HaveConstructor(
IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith(
$"Expected constructor {{context:type}}({GetParameterString(parameterTypes)}) to exist{{reason}}" +
", but {context:type} is <null>.");
ConstructorInfo constructorInfo = null;
if (assertionChain.Succeeded)
{
constructorInfo = Subject.GetConstructor(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(constructorInfo is not null)
.FailWith(
$"Expected constructor {Subject}({GetParameterString(parameterTypes)}) to exist{{reason}}" +
", but it does not.");
}
return new AndWhichConstraint<TypeAssertions, ConstructorInfo>(this, constructorInfo);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has a default constructor.
/// </summary>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
public AndWhichConstraint<TypeAssertions, ConstructorInfo> HaveDefaultConstructor(
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
return HaveConstructor([], because, becauseArgs);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have a constructor with <paramref name="parameterTypes"/>.
/// </summary>
/// <param name="parameterTypes">The parameter types for the indexer.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
public AndWhichConstraint<TypeAssertions, ConstructorInfo> NotHaveConstructor(
IEnumerable<Type> parameterTypes,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith(
$"Expected constructor {{context:type}}({GetParameterString(parameterTypes)}) not to exist{{reason}}" +
", but {context:type} is <null>.");
ConstructorInfo constructorInfo = null;
if (assertionChain.Succeeded)
{
constructorInfo = Subject.GetConstructor(parameterTypes);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(constructorInfo is null)
.FailWith(
$"Expected constructor {Subject}({GetParameterString(parameterTypes)}) not to exist{{reason}}" +
", but it does.");
}
return new AndWhichConstraint<TypeAssertions, ConstructorInfo>(this, constructorInfo);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have a default constructor.
/// </summary>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
public AndWhichConstraint<TypeAssertions, ConstructorInfo> NotHaveDefaultConstructor(
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
return NotHaveConstructor([], because, becauseArgs);
}
private static string GetParameterString(IEnumerable<Type> parameterTypes)
{
return string.Join(", ", parameterTypes.Select(p => p.FullName));
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has the specified C# <paramref name="accessModifier"/>.
/// </summary>
/// <param name="accessModifier">The expected C# access modifier.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="accessModifier"/>
/// is not a <see cref="CSharpAccessModifier"/> value.</exception>
public AndConstraint<TypeAssertions> HaveAccessModifier(
CSharpAccessModifier accessModifier,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith($"Expected {{context:type}} to be {accessModifier}{{reason}}, but {{context:type}} is <null>.");
if (assertionChain.Succeeded)
{
CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
assertionChain.ForCondition(accessModifier == subjectAccessModifier)
.BecauseOf(because, becauseArgs)
.ForCondition(accessModifier == subjectAccessModifier)
.FailWith(
$"Expected {{context:type}} {Subject.Name} to be {accessModifier}{{reason}}" +
$", but it is {subjectAccessModifier}.");
}
return new AndConstraint<TypeAssertions>(this);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have the specified C# <paramref name="accessModifier"/>.
/// </summary>
/// <param name="accessModifier">The unexpected C# access modifier.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="accessModifier"/>
/// is not a <see cref="CSharpAccessModifier"/> value.</exception>
public AndConstraint<TypeAssertions> NotHaveAccessModifier(
CSharpAccessModifier accessModifier,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith($"Expected {{context:type}} not to be {accessModifier}{{reason}}, but {{context:type}} is <null>.");
if (assertionChain.Succeeded)
{
CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
assertionChain
.ForCondition(accessModifier != subjectAccessModifier)
.BecauseOf(because, becauseArgs)
.ForCondition(accessModifier != subjectAccessModifier)
.FailWith($"Expected {{context:type}} {Subject.Name} not to be {accessModifier}{{reason}}, but it is.");
}
return new AndConstraint<TypeAssertions>(this);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has an implicit conversion operator that converts
/// <typeparamref name="TSource"/> into <typeparamref name="TTarget"/>.
/// </summary>
/// <typeparam name="TSource">The type to convert from.</typeparam>
/// <typeparam name="TTarget">The type to convert to.</typeparam>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
public AndWhichConstraint<TypeAssertions, MethodInfo> HaveImplicitConversionOperator<TSource, TTarget>(
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
return HaveImplicitConversionOperator(typeof(TSource), typeof(TTarget), because, becauseArgs);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has an implicit conversion operator that converts
/// <paramref name="sourceType"/> into <paramref name="targetType"/>.
/// </summary>
/// <param name="sourceType">The type to convert from.</param>
/// <param name="targetType">The type to convert to.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="sourceType"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="targetType"/> is <see langword="null"/>.</exception>
public AndWhichConstraint<TypeAssertions, MethodInfo> HaveImplicitConversionOperator(
Type sourceType, Type targetType,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(sourceType);
Guard.ThrowIfArgumentIsNull(targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith("Expected public static implicit {0}({1}) to exist{reason}, but {context:type} is <null>.",
targetType, sourceType);
MethodInfo methodInfo = null;
if (assertionChain.Succeeded)
{
methodInfo = Subject.GetImplicitConversionOperator(sourceType, targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(methodInfo is not null)
.FailWith("Expected public static implicit {0}({1}) to exist{reason}, but it does not.",
targetType, sourceType);
}
return new AndWhichConstraint<TypeAssertions, MethodInfo>(this, methodInfo, assertionChain);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have an implicit conversion operator that converts
/// <typeparamref name="TSource"/> into <typeparamref name="TTarget"/>.
/// </summary>
/// <typeparam name="TSource">The type to convert from.</typeparam>
/// <typeparam name="TTarget">The type to convert to.</typeparam>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
public AndConstraint<TypeAssertions> NotHaveImplicitConversionOperator<TSource, TTarget>(
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
return NotHaveImplicitConversionOperator(typeof(TSource), typeof(TTarget), because, becauseArgs);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have an implicit conversion operator that converts
/// <paramref name="sourceType"/> into <paramref name="targetType"/>.
/// </summary>
/// <param name="sourceType">The type to convert from.</param>
/// <param name="targetType">The type to convert to.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="sourceType"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="targetType"/> is <see langword="null"/>.</exception>
public AndConstraint<TypeAssertions> NotHaveImplicitConversionOperator(
Type sourceType, Type targetType,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(sourceType);
Guard.ThrowIfArgumentIsNull(targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith("Expected public static implicit {0}({1}) to not exist{reason}, but {context:type} is <null>.",
targetType, sourceType);
if (assertionChain.Succeeded)
{
MethodInfo methodInfo = Subject.GetImplicitConversionOperator(sourceType, targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(methodInfo is null)
.FailWith("Expected public static implicit {0}({1}) to not exist{reason}, but it does.",
targetType, sourceType);
}
return new AndConstraint<TypeAssertions>(this);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has an explicit conversion operator that converts
/// <typeparamref name="TSource"/> into <typeparamref name="TTarget"/>.
/// </summary>
/// <typeparam name="TSource">The type to convert from.</typeparam>
/// <typeparam name="TTarget">The type to convert to.</typeparam>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
public AndWhichConstraint<TypeAssertions, MethodInfo> HaveExplicitConversionOperator<TSource, TTarget>(
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
return HaveExplicitConversionOperator(typeof(TSource), typeof(TTarget), because, becauseArgs);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> has an explicit conversion operator that converts
/// <paramref name="sourceType"/> into <paramref name="targetType"/>.
/// </summary>
/// <param name="sourceType">The type to convert from.</param>
/// <param name="targetType">The type to convert to.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="sourceType"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="targetType"/> is <see langword="null"/>.</exception>
public AndWhichConstraint<TypeAssertions, MethodInfo> HaveExplicitConversionOperator(
Type sourceType, Type targetType,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(sourceType);
Guard.ThrowIfArgumentIsNull(targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith("Expected public static explicit {0}({1}) to exist{reason}, but {context:type} is <null>.",
targetType, sourceType);
MethodInfo methodInfo = null;
if (assertionChain.Succeeded)
{
methodInfo = Subject.GetExplicitConversionOperator(sourceType, targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(methodInfo is not null)
.FailWith("Expected public static explicit {0}({1}) to exist{reason}, but it does not.",
targetType, sourceType);
}
return new AndWhichConstraint<TypeAssertions, MethodInfo>(this, methodInfo);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have an explicit conversion operator that converts
/// <typeparamref name="TSource"/> into <typeparamref name="TTarget"/>.
/// </summary>
/// <typeparam name="TSource">The type to convert from.</typeparam>
/// <typeparam name="TTarget">The type to convert to.</typeparam>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
public AndConstraint<TypeAssertions> NotHaveExplicitConversionOperator<TSource, TTarget>(
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
return NotHaveExplicitConversionOperator(typeof(TSource), typeof(TTarget), because, becauseArgs);
}
/// <summary>
/// Asserts that the current <see cref="Type"/> does not have an explicit conversion operator that converts
/// <paramref name="sourceType"/> into <paramref name="targetType"/>.
/// </summary>
/// <param name="sourceType">The type to convert from.</param>
/// <param name="targetType">The type to convert to.</param>
/// <param name="because">
/// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name="becauseArgs">
/// Zero or more objects to format using the placeholders in <paramref name="because"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="sourceType"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="targetType"/> is <see langword="null"/>.</exception>
public AndConstraint<TypeAssertions> NotHaveExplicitConversionOperator(
Type sourceType, Type targetType,
[StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
{
Guard.ThrowIfArgumentIsNull(sourceType);
Guard.ThrowIfArgumentIsNull(targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(Subject is not null)
.FailWith("Expected public static explicit {0}({1}) to not exist{reason}, but {context:type} is <null>.",
targetType, sourceType);
if (assertionChain.Succeeded)
{
MethodInfo methodInfo = Subject.GetExplicitConversionOperator(sourceType, targetType);
assertionChain
.BecauseOf(because, becauseArgs)
.ForCondition(methodInfo is null)
.FailWith("Expected public static explicit {0}({1}) to not exist{reason}, but it does.",
targetType, sourceType);
}
return new AndConstraint<TypeAssertions>(this);
}
/// <summary>
/// Returns the type of the subject the assertion applies on.
/// </summary>
protected override string Identifier => "type";
private void AssertThatSubjectIsClass()
{
if (Subject.IsInterface || Subject.IsValueType || typeof(Delegate).IsAssignableFrom(Subject.BaseType))
{
throw new InvalidOperationException($"{Subject} must be a class.");
}
}
}
| whose |
csharp | EventStore__EventStore | src/SchemaRegistry/KurrentDB.SchemaRegistry.Tests/Modules/Schemas/Domain/UpdateSchemaCommandTests.cs | {
"start": 5753,
"end": 6238
} | public class ____ : TestCaseGenerator<SchemaDetails, string, string> {
protected override IEnumerable<(SchemaDetails, string, string)> Data() {
yield return (
new SchemaDetails { Compatibility = CompatibilityMode.Forward },
"Details.Compatibility",
"Compatibility mode is not modifiable"
);
yield return (
new SchemaDetails { DataFormat = SchemaFormat.Protobuf },
"Details.DataFormat",
"DataFormat is not modifiable"
);
}
}
| NotModifiableTestCases |
csharp | RicoSuter__NSwag | src/NSwag.Core/OpenApiParameterKind.cs | {
"start": 639,
"end": 1707
} | public enum ____
{
/// <summary>An undefined kind.</summary>
[EnumMember(Value = "undefined")]
Undefined,
/// <summary>A JSON object as POST or PUT body (only one parameter of this type is allowed). </summary>
[EnumMember(Value = "body")]
Body,
/// <summary>A query key-value pair. </summary>
[EnumMember(Value = "query")]
Query,
/// <summary>An URL path placeholder. </summary>
[EnumMember(Value = "path")]
Path,
/// <summary>A HTTP header parameter.</summary>
[EnumMember(Value = "header")]
Header,
/// <summary>A form data parameter.</summary>
[EnumMember(Value = "formData")]
FormData,
/// <summary>A model binding parameter (either form data, path or query; by default query; generated by Swashbuckle).</summary>
[EnumMember(Value = "modelbinding")]
ModelBinding,
/// <summary>A cookie. </summary>
[EnumMember(Value = "cookie")]
Cookie,
}
} | OpenApiParameterKind |
csharp | Tyrrrz__YoutubeExplode | YoutubeExplode/Common/IBatchItem.cs | {
"start": 347,
"end": 455
} | public interface ____ { }
/// <summary>
/// Extensions for <see cref="IBatchItem" />.
/// </summary>
| IBatchItem |
csharp | ServiceStack__ServiceStack | ServiceStack.OrmLite/tests/ServiceStack.OrmLite.Tests/Issues/MultiColumnOrderByDescending.cs | {
"start": 2114,
"end": 2756
} | public class ____
{
public int Id { get; set; }
public double Value { get; set; }
public DateTime? Time { get; set; }
}
[Test]
public void Can_OrderBy_DateTime()
{
using var db = OpenDbConnection();
db.DropAndCreateTable<Record>();
db.InsertAll([
new Record
{
Id = 1,
Value = 50,
Time = DateTime.Now,
}
]);
var q = db.From<Record>();
q.OrderByDescending(x => x.Time ?? DateTime.UtcNow);
var results = db.Select(q);
results.PrintDump();
}
} | Record |
csharp | dotnet__maui | src/Controls/tests/DeviceTests/Elements/HybridWebView/HybridWebViewTests_Interception.cs | {
"start": 397,
"end": 13780
} | public partial class ____ : HybridWebViewTestsBase
{
[Fact]
public Task RequestsCanBeInterceptedAndCustomDataReturned() =>
RunTest(async (hybridWebView) =>
{
hybridWebView.WebResourceRequested += (sender, e) =>
{
if (e.Uri.Host == "0.0.0.1")
{
// 1. Create the response data
var response = new EchoResponseObject { message = $"Hello real endpoint (param1={e.QueryParameters["param1"]}, param2={e.QueryParameters["param2"]})" };
var responseData = JsonSerializer.SerializeToUtf8Bytes(response);
var responseLength = responseData.Length.ToString(CultureInfo.InvariantCulture);
// 2. Create the response
e.SetResponse(200, "OK", "application/json", new MemoryStream(responseData));
// 3. Let the app know we are handling it entirely
e.Handled = true;
}
};
var responseObject = await hybridWebView.InvokeJavaScriptAsync<EchoResponseObject>(
"RequestsWithAppUriCanBeIntercepted",
InterceptionJsonContext.Default.EchoResponseObject);
Assert.NotNull(responseObject);
Assert.Equal("Hello real endpoint (param1=value1, param2=value2)", responseObject.message);
});
[Fact]
public Task RequestsCanBeInterceptedAndAsyncCustomDataReturned() =>
RunTest(async (hybridWebView) =>
{
hybridWebView.WebResourceRequested += (sender, e) =>
{
if (e.Uri.Host == "0.0.0.1")
{
// 1. Create the response
e.SetResponse(200, "OK", "application/json", GetDataAsync(e.QueryParameters));
// 2. Let the app know we are handling it entirely
e.Handled = true;
}
};
var responseObject = await hybridWebView.InvokeJavaScriptAsync<EchoResponseObject>(
"RequestsWithAppUriCanBeIntercepted",
InterceptionJsonContext.Default.EchoResponseObject);
Assert.NotNull(responseObject);
Assert.Equal("Hello real endpoint (param1=value1, param2=value2)", responseObject.message);
static async Task<Stream?> GetDataAsync(IReadOnlyDictionary<string, string> queryParams)
{
var response = new EchoResponseObject { message = $"Hello real endpoint (param1={queryParams["param1"]}, param2={queryParams["param2"]})" };
var ms = new MemoryStream();
await Task.Delay(1000);
await JsonSerializer.SerializeAsync(ms, response);
await Task.Delay(1000);
ms.Position = 0;
return ms;
}
});
#if !ANDROID // Custom schemes are not supported on Android
#if !WINDOWS // TODO: There seems to be a bug with the implementation in the WASDK version of WebView2
[Theory]
[InlineData("app://echoservice/", "RequestsWithCustomSchemeCanBeIntercepted")]
#endif
#endif
#if !IOS && !MACCATALYST // Cannot intercept https requests on iOS/MacCatalyst
[Theory(Skip = "Failing on Helix https://github.com/dotnet/maui/issues/32400")]
[InlineData("https://echo.free.beeceptor.com/", "RequestsCanBeIntercepted")]
#endif
public Task RequestsCanBeInterceptedAndCustomDataReturnedForDifferentHosts(string uriBase, string function) =>
RunTest(async (hybridWebView) =>
{
// NOTE: skip this test on older Android devices because it is not currently supported on these versions
if (OperatingSystem.IsAndroid() && !OperatingSystem.IsAndroidVersionAtLeast(25))
{
return;
}
hybridWebView.WebResourceRequested += (sender, e) =>
{
if (new Uri(uriBase).IsBaseOf(e.Uri) && !e.Method.Equals("OPTIONS", StringComparison.OrdinalIgnoreCase))
{
// 1. Get the request from the platform args
var name = e.Headers["X-Echo-Name"];
// 2. Create the response data
var response = new EchoResponseObject
{
message = $"Hello {name} (param1={e.QueryParameters["param1"]}, param2={e.QueryParameters["param2"]})",
};
var responseData = JsonSerializer.SerializeToUtf8Bytes(response);
var responseLength = responseData.Length.ToString(CultureInfo.InvariantCulture);
// 3. Create the response
var headers = new Dictionary<string, string>
{
["Content-Length"] = responseLength,
["Access-Control-Allow-Origin"] = "*",
["Access-Control-Allow-Headers"] = "*",
["Access-Control-Allow-Methods"] = "GET",
};
e.SetResponse(200, "OK", headers, new MemoryStream(responseData));
// 4. Let the app know we are handling it entirely
e.Handled = true;
}
};
var responseObject = await hybridWebView.InvokeJavaScriptAsync<EchoResponseObject>(
function,
InterceptionJsonContext.Default.EchoResponseObject);
Assert.NotNull(responseObject);
Assert.Equal("Hello Matthew (param1=value1, param2=value2)", responseObject.message);
});
#if !ANDROID // Custom schemes are not supported on Android
#if !WINDOWS // TODO: There seems to be a bug with the implementation in the WASDK version of WebView2
[Theory]
[InlineData("app://echoservice/", "RequestsWithCustomSchemeCanBeIntercepted")]
#endif
#endif
#if !IOS && !MACCATALYST // Cannot intercept https requests on iOS/MacCatalyst
[Theory(Skip = "Failing on Helix https://github.com/dotnet/maui/issues/32400")]
[InlineData("https://echo.free.beeceptor.com/", "RequestsCanBeIntercepted")]
#endif
public Task RequestsCanBeInterceptedAndHeadersAddedForDifferentHosts(string uriBase, string function) =>
RunTest(async (hybridWebView) =>
{
// NOTE: skip this test on older Android devices because it is not currently supported on these versions
if (OperatingSystem.IsAndroid() && !OperatingSystem.IsAndroidVersionAtLeast(25))
{
return;
}
const string ExpectedHeaderValue = "My Header Value";
hybridWebView.WebResourceRequested += (sender, e) =>
{
if (new Uri(uriBase).IsBaseOf(e.Uri) && !e.Method.Equals("OPTIONS", StringComparison.OrdinalIgnoreCase))
{
Assert.NotNull(e.PlatformArgs);
Assert.NotNull(e.PlatformArgs.Request);
#if WINDOWS
// Add the desired header for Windows by modifying the request
e.PlatformArgs.Request.Headers.SetHeader("X-Request-Header", ExpectedHeaderValue);
#elif IOS || MACCATALYST
// We are going to handle this ourselves
e.Handled = true;
// Intercept the request and add the desired header to a copy of the request
var task = e.PlatformArgs.UrlSchemeTask;
// Create a mutable copy of the request (this preserves all existing headers and properties)
var request = (Foundation.NSMutableUrlRequest)e.PlatformArgs.Request.MutableCopy();
// Set the URL to the desired request URL as iOS only allows us to intercept non-https requests
request.Url = new("https://echo.free.beeceptor.com/sample-request");
// Add our custom header
Assert.NotNull(request.Headers);
var headers = (Foundation.NSMutableDictionary)request.Headers.MutableCopy();
headers[(Foundation.NSString)"X-Request-Header"] = (Foundation.NSString)ExpectedHeaderValue;
request.Headers = headers;
// Create a session configuration and session to send the request
var configuration = Foundation.NSUrlSessionConfiguration.DefaultSessionConfiguration;
var session = Foundation.NSUrlSession.FromConfiguration(configuration);
// Create a data task to send the request and get the response
var dataTask = session.CreateDataTask(request, (data, response, error) =>
{
if (error is not null)
{
// Handle the error by completing the task with an error response
task.DidFailWithError(error);
return;
}
if (response is Foundation.NSHttpUrlResponse httpResponse)
{
// Forward the response headers and status
task.DidReceiveResponse(httpResponse);
// Forward the response body if any
if (data != null)
{
task.DidReceiveData(data);
}
// Complete the task
task.DidFinish();
}
else
{
// Fallback for non-HTTP responses or unexpected response type
task.DidFailWithError(new Foundation.NSError(new Foundation.NSString("HybridWebViewError"), -1, null));
}
});
// Start the request
dataTask.Resume();
#elif ANDROID
// We are going to handle this ourselves
e.Handled = true;
// Intercept the request and add the desired header to a new request
var request = e.PlatformArgs.Request;
// Copy the request
var url = new Java.Net.URL(request.Url!.ToString());
var connection = (Java.Net.HttpURLConnection)url.OpenConnection()!;
connection.RequestMethod = request.Method;
foreach (var header in request.RequestHeaders!)
{
connection.SetRequestProperty(header.Key, header.Value);
}
// Add our custom header
connection.SetRequestProperty("X-Request-Header", ExpectedHeaderValue);
// Set the response property
e.PlatformArgs.Response = new global::Android.Webkit.WebResourceResponse(
connection.ContentType,
connection.ContentEncoding ?? "UTF-8",
(int)connection.ResponseCode,
connection.ResponseMessage ?? connection.ResponseCode.ToString(),
new Dictionary<string, string>
{
["Access-Control-Allow-Origin"] = "*",
["Access-Control-Allow-Headers"] = "*",
["Access-Control-Allow-Methods"] = "GET",
},
connection.InputStream);
#endif
}
};
var responseObject = await hybridWebView.InvokeJavaScriptAsync<ResponseObject>(
function,
InterceptionJsonContext.Default.ResponseObject);
Assert.NotNull(responseObject);
Assert.NotNull(responseObject.headers);
Assert.True(responseObject.headers.TryGetValue("X-Request-Header", out var actualHeaderValue));
Assert.Equal(ExpectedHeaderValue, actualHeaderValue);
});
[Theory]
#if !ANDROID // Custom schemes are not supported on Android
#if !WINDOWS // TODO: There seems to be a bug with the implementation in the WASDK version of WebView2
[InlineData("app://echoservice/", "RequestsWithCustomSchemeCanBeIntercepted")]
#endif
#endif
#if !IOS && !MACCATALYST // Cannot intercept https requests on iOS/MacCatalyst
[InlineData("https://echo.free.beeceptor.com/", "RequestsCanBeIntercepted")]
#endif
public Task RequestsCanBeInterceptedAndCancelledForDifferentHosts(string uriBase, string function) =>
RunTest(async (hybridWebView) =>
{
var intercepted = false;
hybridWebView.WebResourceRequested += (sender, e) =>
{
if (new Uri(uriBase).IsBaseOf(e.Uri))
{
intercepted = true;
// 1. Create the response
e.SetResponse(403, "Forbidden");
// 2. Let the app know we are handling it entirely
e.Handled = true;
}
};
await Assert.ThrowsAsync<HybridWebViewInvokeJavaScriptException>(() =>
hybridWebView.InvokeJavaScriptAsync<ResponseObject>(
function,
InterceptionJsonContext.Default.ResponseObject));
Assert.True(intercepted, "Request was not intercepted");
});
#if !ANDROID // Custom schemes are not supported on Android
#if !WINDOWS // TODO: There seems to be a bug with the implementation in the WASDK version of WebView2
[Theory]
[InlineData("app://echoservice/", "RequestsWithCustomSchemeCanBeIntercepted")]
#endif
#endif
#if !IOS && !MACCATALYST // Cannot intercept https requests on iOS/MacCatalyst
[Theory(Skip = "Failing on Helix https://github.com/dotnet/maui/issues/32400")]
[InlineData("https://echo.free.beeceptor.com/", "RequestsCanBeIntercepted")]
#endif
public Task RequestsCanBeInterceptedAndCaseInsensitiveHeadersRead(string uriBase, string function) =>
RunTest(async (hybridWebView) =>
{
// NOTE: skip this test on older Android devices because it is not currently supported on these versions
if (OperatingSystem.IsAndroid() && !OperatingSystem.IsAndroidVersionAtLeast(25))
{
return;
}
var headerValues = new Dictionary<string, string>();
hybridWebView.WebResourceRequested += (sender, e) =>
{
if (new Uri(uriBase).IsBaseOf(e.Uri) && !e.Method.Equals("OPTIONS", StringComparison.OrdinalIgnoreCase))
{
// Should be exactly as set in the JS
try
{ headerValues["X-Echo-Name"] = e.Headers["X-Echo-Name"]; }
catch (Exception ex)
{ headerValues["X-Echo-Name"] = ex.Message; }
// Sometimes lowercase is used
try
{ headerValues["x-echo-name"] = e.Headers["x-echo-name"]; }
catch (Exception ex)
{ headerValues["x-echo-name"] = ex.Message; }
// This should never actually occur
try
{ headerValues["X-ECHO-name"] = e.Headers["X-ECHO-name"]; }
catch (Exception ex)
{ headerValues["X-ECHO-name"] = ex.Message; }
// If the request is for the app:// resources, we return an empty response
// because the tests are not doing anything with the response.
if (e.Uri.Scheme == "app")
{
var headers = new Dictionary<string, string>
{
["Content-Type"] = "application/json",
["Access-Control-Allow-Origin"] = "*",
["Access-Control-Allow-Headers"] = "*",
["Access-Control-Allow-Methods"] = "GET",
};
e.SetResponse(200, "OK", headers, new MemoryStream(Encoding.UTF8.GetBytes("{}")));
e.Handled = true;
}
}
};
var responseObject = await hybridWebView.InvokeJavaScriptAsync<EchoResponseObject>(
function,
InterceptionJsonContext.Default.EchoResponseObject);
Assert.NotEmpty(headerValues);
Assert.Equal("Matthew", headerValues["X-Echo-Name"]);
Assert.Equal("Matthew", headerValues["x-echo-name"]);
Assert.Equal("Matthew", headerValues["X-ECHO-name"]);
});
| HybridWebViewTests_Interception |
csharp | dotnet__reactive | Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncGrouping.cs | {
"start": 948,
"end": 1073
} | public interface ____<out TKey, out TElement> : IAsyncEnumerable<TElement>
{
TKey Key { get; }
}
}
| IAsyncGrouping |
csharp | unoplatform__uno | src/Uno.UWP/Generated/3.0.0.0/Windows.Devices.Input.Preview/GazeDeviceWatcherAddedPreviewEventArgs.cs | {
"start": 304,
"end": 1284
} | public partial class ____
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
internal GazeDeviceWatcherAddedPreviewEventArgs()
{
}
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
[global::Uno.NotImplemented("__ANDROID__", "__IOS__", "__TVOS__", "IS_UNIT_TESTS", "__WASM__", "__SKIA__", "__NETSTD_REFERENCE__")]
public global::Windows.Devices.Input.Preview.GazeDevicePreview Device
{
get
{
throw new global::System.NotImplementedException("The member GazeDevicePreview GazeDeviceWatcherAddedPreviewEventArgs.Device is not implemented. For more information, visit https://aka.platform.uno/notimplemented#m=GazeDevicePreview%20GazeDeviceWatcherAddedPreviewEventArgs.Device");
}
}
#endif
// Forced skipping of method Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs.Device.get
}
}
| GazeDeviceWatcherAddedPreviewEventArgs |
csharp | duplicati__duplicati | Duplicati/Library/Utility/PermissionHelper.cs | {
"start": 4920,
"end": 5632
} | struct ____
{
public uint LowPart;
public int HighPart;
/// <inheritdoc/>
public override bool Equals(object? obj)
{
return obj is LUID other &&
LowPart == other.LowPart &&
HighPart == other.HighPart;
}
/// <inheritdoc/>
public override int GetHashCode()
{
return HashCode.Combine(LowPart, HighPart);
}
}
/// <summary>
/// Structure that contains a locally unique identifier (LUID) and its attributes.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
| LUID |
csharp | dotnet__aspnetcore | src/Mvc/test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/BindPropertiesOnModel.cs | {
"start": 261,
"end": 413
} | public class ____ : PageModel
{
[FromQuery]
public string Property1 { get; set; }
public string Property2 { get; set; }
}
| BindPropertiesOnModel |
csharp | OrchardCMS__OrchardCore | src/OrchardCore.Modules/OrchardCore.ContentFields/Settings/LocalizationSetContentPickerFieldSettings.cs | {
"start": 183,
"end": 360
} | public class ____ : FieldSettings
{
public bool Multiple { get; set; }
public string[] DisplayedContentTypes { get; set; } = [];
}
| LocalizationSetContentPickerFieldSettings |
csharp | CommunityToolkit__dotnet | tests/CommunityToolkit.Mvvm.SourceGenerators.Roslyn4001.UnitTests/Test_ClassUsingAttributeInsteadOfInheritanceCodeFixer.cs | {
"start": 4844,
"end": 6042
} | class ____ : Attribute
{
}
""";
CSharpCodeFixTest test = new()
{
TestCode = original,
FixedCode = @fixed,
ReferenceAssemblies = ReferenceAssemblies.Net.Net80
};
test.TestState.AdditionalReferences.Add(typeof(ObservableObject).Assembly);
test.ExpectedDiagnostics.AddRange(new[]
{
// /0/Test0.cs(5,15): warning <DIAGNOSTIC_ID>: The type C is using the <ATTRIBUTE_TYPE> attribute while having no base type, and it should instead inherit from ObservableObject
CSharpCodeFixVerifier.Diagnostic(diagnosticId).WithSpan(7, 7, 7, 8).WithArguments("C")
});
await test.RunAsync();
}
[TestMethod]
[DataRow("INotifyPropertyChanged", "MVVMTK0032")]
[DataRow("ObservableObject", "MVVMTK0033")]
public async Task MultipleAttributeLists_OneAfterTarget(string attributeTypeName, string diagnosticId)
{
string original = $$"""
using System;
using CommunityToolkit.Mvvm.ComponentModel;
// This is some trivia
[{{attributeTypeName}}]
[Test]
| TestAttribute |
csharp | dotnetcore__CAP | samples/Sample.ConsoleApp/Program.cs | {
"start": 1481,
"end": 1860
} | public class ____ : SubscribeFilter
{
public override Task OnSubscribeExceptionAsync(ExceptionContext context)
{
if (context.Exception.InnerException is TimeoutException)
{
throw new TimeoutException("Http request timeout");
}
return base.OnSubscribeExceptionAsync(context);
}
}
} | Filter |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.