static void Main(string[] args)
{
ExternalClass myObj = new ExternalClass();
Console.WriteLine(myObj.ToString());
Console.ReadKey();
}
private void btnUnload_Click(object sender, RoutedEventArgs e)
{
ecs = null;
ec = null;
GC.Collect();
GC.WaitForPendingFinalizers();
}
public void Run()
{
var c = new ExternalClass();
MethodCount = c.Methods.Count;
c.MethodExecuted += MethodExecuted;
c.Run(null);
}
private void btnLoad_Click(object sender, RoutedEventArgs e)
{
ecs = new ExternalClass_Slam();
ec = new ExternalClass();
while (!cancel)
{
Console.WriteLine(ecs.ImExternal());
Console.WriteLine(ec.ImExternal());
Thread.Sleep(1000);
}
}
public void TestExternalStaticMethodCall()
{
Func <Column, Column> udf = Udf <string, string>(str =>
{
return(ExternalClass.HelloWorld());
});
Row[] rows = _df.Select(udf(_df["name"])).Collect().ToArray();
Assert.Equal(3, rows.Length);
for (int i = 0; i < rows.Length; ++i)
{
Row row = rows[i];
Assert.Equal(1, row.Size());
Assert.Equal("Hello World", row.GetAs <string>(0));
}
}
public static void TestExternalClass()
{
/*@ Bridge.ClientTest.Batch3.BridgeIssues.Bridge2770.ExternalClass = function() {
* this.Foo = function(s) {
* if (s == null) {
* return "Empty";
* }
* return s.toString();
* }
* };
*/
var c = new ExternalClass();
Assert.AreEqual("test", c.Foo("test"));
Assert.AreEqual("true", c.Foo(true));
Assert.AreEqual("Empty", c.Foo());
}
public void TestUdfClosure()
{
var ec = new ExternalClass("Hello");
Func <Column, Column> udf = Udf <string, string>(
(str) =>
{
return(ec.Concat(str));
});
Row[] rows = _df.Select(udf(_df["name"])).Collect().ToArray();
Assert.Equal(3, rows.Length);
var expected = new[] { "HelloMichael", "HelloAndy", "HelloJustin" };
for (int i = 0; i < rows.Length; ++i)
{
Row row = rows[i];
Assert.Equal(1, row.Size());
Assert.Equal(expected[i], row.GetAs <string>(0));
}
}
public void TestInitExternalClassInUdf()
{
// Instantiate external assembly class within body of Udf.
Func <Column, Column> udf = Udf <string, string>(
(str) =>
{
var ec = new ExternalClass("Hello");
return(ec.Concat(str));
});
Row[] rows = _df.Select(udf(_df["name"])).Collect().ToArray();
Assert.Equal(3, rows.Length);
var expected = new string[] { "HelloMichael", "HelloAndy", "HelloJustin" };
for (int i = 0; i < rows.Length; ++i)
{
Row row = rows[i];
Assert.Equal(1, row.Size());
Assert.Equal(expected[i], row.GetAs <string>(0));
}
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static ExternalClass DeserializeLength(Stream stream, int length)
{
ExternalClass instance = new ExternalClass();
DeserializeLength(stream, length, instance);
return instance;
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static ExternalClass DeserializeLengthDelimited(Stream stream)
{
ExternalClass instance = new ExternalClass();
DeserializeLengthDelimited(stream, instance);
return instance;
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static ExternalClass Deserialize(Stream stream)
{
ExternalClass instance = new ExternalClass();
Deserialize(stream, instance);
return instance;
}
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary>
public static ExternalClass Deserialize(byte[] buffer)
{
ExternalClass instance = new ExternalClass();
using (var ms = new MemoryStream(buffer))
Deserialize(ms, instance);
return instance;
}
public void OnGet()
{
var extClass = new ExternalClass();
Message = extClass.GetMessage("2");
}
public static void Execute()
{
ExternalClass.SayHello();
}
private void Start()
{
int result = ExternalClass.Add(40, 2);
Debug.Log("Result: " + result);
}
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary>
public static byte[] SerializeToBytes(ExternalClass instance)
{
using (var ms = new MemoryStream())
{
Serialize(ms, instance);
return ms.ToArray();
}
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, ExternalClass instance)
{
// Key for field: 1, Varint
stream.WriteByte(8);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.A);
}
/// <summary>Helper: Serialize with a varint length prefix</summary>
public static void SerializeLengthDelimited(Stream stream, ExternalClass instance)
{
var data = SerializeToBytes(instance);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length);
stream.Write(data, 0, data.Length);
}
public ExternalContainer(ExternalClass @class)
{
_components = new List <IComponent> {
new ExternalDocument(@class)
};
}
public NewClass(ExternalClass externalClass)
{
// you would have to copy all the properties
this.EXproperty1 = externalClass.EXproperty1;
}
public ExternalDocument(ExternalClass @class)
{
_class = @class;
}
