public void ImmutableWrapperTypesAreNotCopied()
{
var original = Immutable.Create(new object[] { 123, "hello!" });
var result = DeepCopier.Copy(original);
Assert.Same(original.Value, result.Value);
}
public RealEntity(int id, Credentials <RealEntity> credentials, Address address, BirthInformation birthInformation)
{
Id = id;
Credentials = Immutable.Create(credentials);
BirthInformation = Immutable.Create(birthInformation);
Address = Immutable.Create(address);
}
static void Main(string[] args)
{
try
{
Immutable.Create();
//CreateRemoteService();
XPressionWCFServer service = new XPressionWCFServer();
service.Create("9000");
service.Open();
Console.WriteLine("Service Started - " + DateTime.Now.ToString());
string result;
do
{
result = Console.ReadLine();
if (result == "R")
{
Process.Start("server.exe");
Environment.Exit(0);
}
}while (result != "Q");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void ServerForm_Load(object sender, EventArgs e)
{
try
{
Immutable.Create();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task Run(object cfnRequest, ILambdaContext context)
{
var request = JsonConvert.DeserializeObject <CfnRequest>(cfnRequest.ToString());
LogHandler.LogMessage(context, JsonConvert.SerializeObject(request));
var response = Immutable.Create(new CfnResponse
{
StackId = request.StackId,
RequestId = request.RequestId,
LogicalResourceId = request.LogicalResourceId,
PhysicalResourceId = $"{context.AwsRequestId}.{request.LogicalResourceId}",
Reason = string.Empty, // Mandatory if status is FAILED
NoEcho = false
});
Immutable <CfnResponse> cfnResponse;
switch (request.RequestType)
{
case "Create":
cfnResponse = await CreateSeed(request, response, context);
break;
case "Delete":
// should be used when table DeletionPolicy is Retain
cfnResponse = await DeleteTable(request, response, context);
break;
default:
cfnResponse = response.Modify(r => r.Status = "SUCCESS");
break;
}
SendResponseToCfn(request, cfnResponse);
}
/// <summary>
/// Creates a new instance of an Immutable using a stuffed enclosed type.
/// </summary>
/// <typeparam name="T">The type to enclose.</typeparam>
/// <param name="self">The instance to create the Immutable from.</param>
/// <returns>A new Immutable with a cloned enclosed instance.</returns>
public static Immutable <T> Create <T>(T self)
{
return(Immutable <T> .Create(self));
}
public Immutable <T> BuildAsImmutable()
{
return(Immutable.Create(_classInstance));
}
/// <summary>
/// Reads an Immutable type from a JSON object.
/// </summary>
/// <param name="reader">The reader to use.</param>
/// <param name="typeToConvert">The immutable type to convert.</param>
/// <param name="options">The serializer options.</param>
/// <returns>A new Immutable instance.</returns>
public override Immutable <T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var value = (T)JsonSerializer.Deserialize(ref reader, _enclosedType, options);
return(Immutable.Create(value));
}
