static void Main()
{
SampleClass mC = new SampleClass(11, 22);
Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
Console.WriteLine("c1 = {0}, c2 = {1}",
SampleClass.c1, SampleClass.c2 );
}
public void ToXml_WhenGivenObject_CanConvertObject()
{
SampleClass sampleClass = new SampleClass { SampleString = "my string" };
var xml = sampleClass.ToXml();
Assert.IsInstanceOf<XDocument>(xml);
StringAssert.Contains(@"<SampleString>my string</SampleString>", xml.ToString());
}
public void DifferentSeedShouldMakeEverythingDifferent()
{
var obj1 = new SampleClass();
var obj2 = new SampleClass();
_sampleValueSetter.AssignSampleValues(obj1, 1);
_sampleValueSetter.AssignSampleValues(obj2, 2);
}
public void SampleValueWithChildObject()
{
var obj = new SampleClass();
obj.Child = new SampleClass();
_sampleValueSetter.AssignSampleValues(obj, 1);
Assert.NotNull(obj.Child.Field1);
}
public void test_bind_no_properties()
{
var registry = new EmptyServiceRegistry();
var instance = new PropertyBinder(registry);
var sample = new SampleClass();
instance.Bind(sample);
Assert(sample.instance == null);
}
static void Main()
{
SampleClass p1 = new SampleClass(11, 21, 32); // OK
Console.WriteLine("p1: x={0}, y={1}, z={2}", p1.x, p1.y, p1.z);
SampleClass p2 = new SampleClass();
p2.x = 55; // OK
Console.WriteLine("p2: x={0}, y={1}, z={2}", p2.x, p2.y, p2.z);
}
public void SampleValueWithChildrenArray()
{
var obj = new SampleClass();
obj.Children.Add(new SampleClass());
obj.Children.Add(new SampleClass());
_sampleValueSetter.AssignSampleValues(obj, 1);
Assert.NotNull(obj.Children.First().Field1);
Assert.NotNull(obj.Children.Last().Field1);
}
static void Main()
{
SampleClass sc = new SampleClass();
IControl ctrl = (IControl)sc;
ISurface srfc = (ISurface)sc;
// The following lines all call the same method.
sc.Paint();
ctrl.Paint();
srfc.Paint();
}
public void test_bind_property()
{
var registry = new FixedServiceRegistry();
var impl = new ImplA();
registry.Bound[typeof(IDepA)] = impl;
var instance = new PropertyBinder(registry);
var sample = new SampleClass();
instance.Bind(sample);
Assert(sample.instance == impl);
}
static void Main()
{
SampleClass p1 = new SampleClass(11, 21, 32); // OK
Console.WriteLine("p1: x={0}, y={1}, z={2}", p1.x, p1.y, p1.z);
SampleClass p2 = new SampleClass();
p2.x = 55; // OK
Console.WriteLine("p2: x={0}, y={1}, z={2}", p2.x, p2.y, p2.z);
}
public static void Example()
{
SampleClass sampleClass1 = new SampleClass(1);
SampleClass sampleClass2 = new SampleClass(1, 2);
SampleClass sampleClass3 = new SampleClass().WithP1(1);
SampleClass sampleClass4 = new SampleClass().WithP1(1).WithP2(2);
Assert.AreEqual(sampleClass2._p2, 2);
Assert.AreEqual(sampleClass4._p2, 2);
}
static void Main(string[] args)
{
Utility utility = new Utility();
SampleClass sampleClass = new SampleClass(); //Change this to any type to get its fields
DataTable dtDocument = new DataTable();
dtDocument = utility.GetNameAndType(sampleClass);
//DataTable to excel functionality
utility.ExportToExcel(dtDocument, $"Documentation_{DateTime.Now.ToString("MMddyyyyHHmm")}.xlsx", "DocumentCSharp");
}
public void TestFunctionReferencePassed()
{
var c = new SampleClass();
var result = c.ThisGenericReferenceDefaultWorks();
Assert.IsFalse(result.Successful);
Assert.IsNotNull(result.raisedException);
Assert.IsInstanceOfType(result.raisedException, typeof(Exception));
Assert.IsInstanceOfType(result.Result, typeof(List <int>));
}
public void TestCleanFileLine(int inputA, int inputB, int expected)
{
//Arrange
SampleClass sc = new SampleClass();
// Act
var result = sc.Mult(inputA, inputB);
// Assert
Assert.AreEqual(expected, result);
}
/// <summary>
/// 同步
/// </summary>
/// <param name="EXCUTE_TIMES"></param>
public void SyncExample(int EXCUTE_TIMES)
{
SampleClass sample = new SampleClass();
for (int i = 0; i < EXCUTE_TIMES; i++)
{
sample.SimpleAdd();
}
Console.WriteLine(sample.SomeCount);
}
public static void Main()
{
var sc = new SampleClass();
IControl ctrl = (IControl)sc;
ISurface srfc = (ISurface)sc;
sc.Paint();
ctrl.Paint();
srfc.Paint();
}
public void WithSchemaUriAndSchemaSet()
{
SampleClass actual = (SampleClass)XmlSerializationUtility.DeserializeUsingSchema(
GetReaderForDefaultFragment(1),
typeof(SampleClass),
GetXmlSchemaSet());
Assert.That(actual, Is.Not.Null);
Assert.That(actual.Value, Is.EqualTo(1));
}
public void TestFunctionPrimitivePassed()
{
var c = new SampleClass();
var result = c.ThisGenericDefaultWorks();
Assert.IsFalse(result.Successful);
Assert.IsNotNull(result.raisedException);
Assert.IsInstanceOfType(result.raisedException, typeof(Exception));
Assert.AreEqual(result.Result, 0);
}
private void Entry()
{
// 추상클래스 인스턴트화 불가능
// SampleClassBase sample = new SampleClassBase();
SampleClass sample = new SampleClass();
sample.HelloPrint();
sample.AbstractMethod();
}
// </SnippetDefaultImplementation>
public static void CallDefaultImplementation()
{
// <SnippetCallDefaultImplementation>
var sample = new SampleClass();
//sample.Paint();// "Paint" isn't accessible.
var control = sample as IControl;
control.Paint();
// </SnippetCallDefaultImplementation>
}
public void SerializeObjectNull()
{
var objectToSerialize = new SampleClass
{
StringFieldBefore = "Hello",
SampleField = null,
StringFieldAfter = "Goodbye",
};
Assert.Equal("{\"StringFieldBefore\":\"Hello\",\"SampleField\":null,\"StringFieldAfter\":\"Goodbye\"}", JsonConvert.SerializeObject(objectToSerialize));
}
static void Main(string[] args)
{
PrintThreadInfo("Main", Thread.CurrentThread);
var sampleInstance = new SampleClass();
sampleInstance = null;
GC.Collect();
Console.ReadKey();
}
public void SampleValueShouldStartFromSeed()
{
var obj = new SampleClass();
_sampleValueSetter.AssignSampleValues(obj, 1, processFields: true, processProperties: false);
Assert.That(obj.Field1, Is.EqualTo("2"));
Assert.Null(obj.Prop1);
_sampleValueSetter.AssignSampleValues(obj, 2, processFields: false, processProperties: true);
Assert.That(obj.Field1, Is.EqualTo("2"));
Assert.That(obj.Prop1, Is.EqualTo("3"));
}
private void Test01()
{
var data = new SampleClass {
Value = new SampleEnum[, ] {
{ SampleEnum.A, SampleEnum.B }, { SampleEnum.C, SampleEnum.A }
}
};
var msg = MessagePackSerializer.Serialize(data);
UnityEngine.Debug.Log(msg);
}
public void DeserializeObject()
{
const string jsonText = "{\"SampleField\":\"SampleValue\"}";
var expected = new SampleClass
{
SampleField = SampleEnum.Sample
};
Assert.Equal(expected, JsonConvert.DeserializeObject <SampleClass>(jsonText));
}
public void CanRetrieveType()
{
Container.Add <SampleClass>();
SampleClass sample = Container.Get <SampleClass>();
Assert.NotNull(sample);
Assert.Equal(1, sample.DoSomething());
Container.Clear();
}
public void WithNamespaceAndSchemaSet()
{
SampleClass actual = (SampleClass)XmlSerializationUtility.DeserializeUsingSchema(
GetReaderForDefaultFragment(1),
typeof(SampleClass),
"http://www.re-motion.org/core/unitTests",
GetXmlSchemaSet());
Assert.That(actual, Is.Not.Null);
Assert.That(actual.Value, Is.EqualTo(1));
}
static void Main()
{
SampleClass sc = new SampleClass();
IControl ctrl = (IControl)sc;
ISurface srfc = (ISurface)sc;
// The following lines all call the same method.
sc.Paint();
ctrl.Paint();
srfc.Paint();
}
public static int AddClass(SampleClass cl)
{
if (cl.z < 100)
{
return(cl.i + cl.j + cl.z);
}
else
{
return(cl.i % 1000);
}
}
public void SerializeObject()
{
var objectToSerialize = new SampleClass
{
StringFieldBefore = "Hello",
SampleField = TimeIdentifier.April,
StringFieldAfter = "Goodbye",
};
Assert.Equal("{\"StringFieldBefore\":\"Hello\",\"SampleField\":{\"value\":\"M4\",\"label\":\"April\"},\"StringFieldAfter\":\"Goodbye\"}", JsonConvert.SerializeObject(objectToSerialize));
}
public void CreateNewRefernce()
{
Mock <IObjectCreator> creatorMock = new Mock <IObjectCreator>();
var target = new ReferenceInfo(5);
SampleClass sampleObject = new SampleClass();
creatorMock.Setup(o => o.GetObjectReference(target)).Returns(sampleObject);
var result = target.GetInstance(creatorMock.Object);
Assert.IsInstanceOfType(result, typeof(SampleClass));
}
public static void Main(string[] args)
{
XmlConfigurator.Configure();
var sample = new SampleClass("sample");
sample.DoSomeSampleStuff();
logger.Info("Info logging");
logger.Debug("Debug message sample");
}
public JsonResult CountJson()
{
var response = new SampleClass()
{
Text = "Hello!",
CurrentTime = DateTime.Now,
RequestNumber = Service.RequestNumber()
};
return(new JsonResult(response));
}
private void Button6_Click(object sender, RoutedEventArgs e)
{
SampleClass sc = new SampleClass();
IControl ctrl = (IControl)sc;
ISurface srfc = (ISurface)sc;
// The following lines all call the same method.
sc.Paint();
ctrl.Paint();
srfc.Paint();
}
private SampleClass CreateNullNestedObject()
{
var sampleClass = new SampleClass()
{
Id = 1,
SomeValue = "Some string value",
NestedValue = null
};
return(sampleClass);
}
public void DoStuff_returns_correct_result()
{
// Arrange
var sut = new SampleClass();
// Act
var result = sut.DoStuff();
// Assert
Assert.Equal(42, result);
}
void ServerCall()
{
var source = new TraceSource("ServerComponent");
using (var lScope = new LogicalOperationScope(source, "Process B"))
{
var sample2 = new SampleClass(source);
sample2.TraceEvent(TraceEventType.Information, 10, "Server Message for the Process");
}
}
private void Cs7Is()
{
object c1 = new SampleClass()
{
Id = 1
};
if (c1 is SampleClass c)
{
Console.WriteLine(c.Id);
}
}
public static void Run()
{
SampleClass sc = new SampleClass();
// Map the delegate to the instance method:
Del d = sc.InstanceMethod;
d();
// Map to the static method:
d = SampleClass.StaticMethod;
d();
}
public static void TestMethod()
{
var internalType =
typeof(Array).GetNestedType(
"ArrayEnumerator", BindingFlags.NonPublic);
var x = new SampleClass();
var type = x.GetType();
var bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
var info = type.GetField("dict", bindingAttr);
var dict = info.GetValue(x) as IDictionary <Type, object>;
var arrayEnumerator = dict[internalType];
}
public void test_bind_property()
{
var registry = new FixedServiceRegistry();
var impl = new ImplA();
registry.Bound[typeof(IDepA)] = impl;
var instance = new PropertyBinder(registry);
var sample = new SampleClass();
instance.Bind(sample);
Assert(sample.instance == impl);
}
public void CanSerialiseAndDeserialise ()
{
// Arrange
var sampleClass = new SampleClass (){ Name = "Foo!" };
var serializedString = Serializer.Serialize (sampleClass);
// Act
var deserializedClass = Serializer.DeSerialize<SampleClass> (serializedString);
// Assert
Assert.IsInstanceOfType (typeof(SampleClass), deserializedClass);
Assert.AreEqual (deserializedClass.Name, sampleClass.Name);
}
public void SerializeDeserializeTest()
{
var file = new IniFile();
var section = file.Sections.Add("Sample Class");
var serializedClass = new SampleClass();
serializedClass.Initialize();
section.Serialize(serializedClass);
var deserializedClass = section.Deserialize<SampleClass>();
Assert.IsTrue(serializedClass.Equals(deserializedClass));
}
static void Main(string[] args)
{
// Displays "SampleMethod inside SampleNamespace."
SampleClass outer = new SampleClass();
outer.SampleMethod();
// Displays "SampleMethod inside SampleNamespace."
SampleNamespace.SampleClass outer2 = new SampleNamespace.SampleClass();
outer2.SampleMethod();
// Displays "SampleMethod inside NestedNamespace."
NestedNamespace.SampleClass inner = new NestedNamespace.SampleClass();
inner.SampleMethod();
}
public void when_exception_is_thrown_while_using_object_initializer_then_object_is_null()
{
SampleClass target = null;
try
{
// Y = 2 will throw exception
target = new SampleClass { X = 1, Y = 2 };
}
catch
{
}
target.Should().BeNull();
}
public void when_exception_is_thrown_while_using_regular_constructor_then_object_is_not_null()
{
SampleClass target = null;
try
{
target = new SampleClass();
target.X = 1;
target.Y = 2; // This throws exception
}
catch
{
}
target.Should().NotBeNull();
}
public void TestMethod2()
{
System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo("en-US");
var test = new SampleClass(new Dictionary<Expression<Func<SampleClass, string>>, Func<string>>
{
{ x => x.Label, () => Foo.MyLabel },
{ x => x.Description, () => Foo.MyDescription }
});
Assert.AreEqual("Label", Foo.MyLabel);
Assert.AreEqual("Description", Foo.MyDescription);
Assert.AreEqual(test.Label, Foo.MyLabel);
Assert.AreEqual(test.Description, Foo.MyDescription);
}
public void TestValuesAreCreated()
{
SessionStateBindingStrategy strategy = new SessionStateBindingStrategy();
MockBuilderContext builderContext = new MockBuilderContext(strategy);
MockSessionStateLocatorService sessionLocator = new MockSessionStateLocatorService();
builderContext.Locator.Add(new DependencyResolutionLocatorKey(typeof (ISessionStateLocatorService), null),
sessionLocator);
SampleClass sample = new SampleClass();
sample.String0 = "test";
strategy.BuildUp(builderContext, typeof (SampleClass), sample, null);
Assert.AreEqual("test", sample.String0);
Assert.IsNotNull(sample.String1);
Assert.IsNotNull(sample.String2);
}
public int Add(string name, string creator)
{
var currentUser = this.users
.All()
.FirstOrDefault(u => u.UserName == creator);
if (currentUser == null)
{
throw new ArgumentException("Current user cannot be found!");
}
var newSample = new SampleClass
{
Name = name,
User = currentUser
};
this.samples.Add(newSample);
this.samples.SaveChanges();
return newSample.SampleId;
}
public string Simulate(string stringArg, SampleClass sample)
{
var del = new DelegateWithArguments();
var args = new MethodArgument[2];
var arg = new MethodArgument();
arg.Index = 0;
arg.Name = "stringArg";
arg.Value = stringArg;
args[0] = arg;
var arg1 = new MethodArgument();
arg1.Index = 1;
arg1.Name = "sample";
arg1.Value = sample;
args[1] = arg1;
return del.Process(() => "lol", args);
}
static void Main()
{
// Create objects using default constructors:
SampleStruct Location1 = new SampleStruct();
SampleClass Employee1 = new SampleClass();
// Display values:
Console.WriteLine("Default values:");
Console.WriteLine(" Struct members: {0}, {1}",
Location1.x, Location1.y);
Console.WriteLine(" Class members: {0}, {1}",
Employee1.name, Employee1.id);
// Create objects using parameterized constructors:
SampleStruct Location2 = new SampleStruct(10, 20);
SampleClass Employee2 = new SampleClass(1234, "Cristina Potra");
// Display values:
Console.WriteLine("Assigned values:");
Console.WriteLine(" Struct members: {0}, {1}",
Location2.x, Location2.y);
Console.WriteLine(" Class members: {0}, {1}",
Employee2.name, Employee2.id);
}
public static void AttributeTest()
{
// Атрибуты обеспечивают эффективный способ связывания метаданных или декларативной информации с кодом (сборками, типами, методами, свойствами и т. д.). После того как атрибут будет связан с программной сущностью, он может быть запрошен во время выполнения с помощью техники, называемой рефлексией.
// Атрибуты имеют следующие свойства:
// - Атрибуты добавляют в программу метаданные. Метаданные представляют собой сведения о типах, определенных в программе.Все сборки .NET содержат заданный набор метаданных, описывающих типы и члены типов, определенных в сборке.Для задания необходимых дополнительных сведений можно добавить атрибуты
// - Один или несколько атрибутов могут применяться к сборкам, модулям или более мелким программным элементам, таким как классы и свойства.
// - Программа может проверить собственные метаданные или метаданные в других программах с помощью рефлексии.
// Атрибуты могут быть размещены в большинстве объявлений, хотя определенный атрибут может ограничить типы объявлений, в которых он допустим.В C# атрибут задается путем размещения его имени, заключенного в квадратные скобки ([]), перед объявлением сущности, к которой он относится
SampleClass myClass = new SampleClass();
// Чтобы отличать атрибуты от других элементов платформы .NET Framework, используется соглашение, по которому все имена атрибутов заканчиваются словом "Attribute" ("атрибут").Однако нет необходимости указывать суффикс атрибута при его использовании в коде.Например, [DllImport] эквивалентен [DllImportAttribute], однако DllImportAttribute является фактическим именем атрибута в платформе .NET Framework.
// Многие атрибуты имеют параметры, которые могут быть позиционными, неименованными или именованными.
//[DllImport("user32.dll")]
//[DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]
//[DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]
// Первый параметр — имя библиотеки DLL — является позиционным и всегда стоит на первом месте; остальные являются именованными.В этом случае оба именованных параметра по умолчанию имеют значение "false" и могут быть пропущены.
// Целевым объектом атрибута является сущность, к которой относится атрибут.Например, атрибут может относиться к классу, отдельному методу или целой сборке.По умолчанию атрибут относится к тому элементу, перед которым он указан.Однако можно явным образом определить, к чему относится атрибут, — например, к методу, его параметру или возвращаемому значению.
// [target : attribute-list]
//Следующий список содержит несколько общих случаев использования атрибутов в коде:
// - Пометка метода веб-службы с помощью атрибута WebMethod для указания на возможность вызова метода с помощью протокола SOAP.Дополнительные сведения см. в разделе WebMethodAttribute.
// - Описание способов упаковки параметров методов при взаимодействии с машинным кодом.Дополнительные сведения см. в разделе MarshalAsAttribute.
// - Описание свойств COM для классов, методов и интерфейсов.
// - Вызов неуправляемого кода с помощью класса DllImportAttribute.
// - Описание сборки с помощью заголовка, версии, описания или торгового знака.
// - Указание того, какие члены класса должны быть сериализованы при сохранении.
// - Описание порядка сопоставления членов класса и XML-узлов при XML-сериализации.
// - Описание требований безопасности к методам.
// - Указание характеристик, используемых для обеспечения безопасности.
// - Управление оптимизацией с помощью JIT-компилятора для того, чтобы отладка кода оставалась простой.
// - Получение сведений об объекте, вызывающем метод.
// Атрибуты обеспечивают эффективный способ связывания метаданных или декларативной информации с кодом.
// !!! more example
// http://habrahabr.ru/post/140842/
}
IEnumerator StartTest()
{
state = State.Starting;
totTweens = int.Parse(tweensList[tweensListId], System.Globalization.NumberStyles.AllowThousands);
testTitle = engineType.ToString();
SampleClass[] cs = null;
Vector3[] toPositions = null;
float[] toFloats = null;
// Prepare test
switch (testType) {
case TestType.Transforms:
ts = new Transform[totTweens];
gos = new GameObject[totTweens];
toPositions = new Vector3[totTweens];
container = new GameObject("Container").transform;
for (int i = 0; i < totTweens; ++i) {
GameObject go = (GameObject)Instantiate(prefab);
if (disableRenderers) go.GetComponent<Renderer>().enabled = false;
Transform t = go.transform;
t.parent = container;
t.position = new Vector3(UnityEngine.Random.Range(-40f, 40f), UnityEngine.Random.Range(-40f, 40f), UnityEngine.Random.Range(-40f, 40f));
gos[i] = go;
ts[i] = t;
toPositions[i] = new Vector3(UnityEngine.Random.Range(-40f, 40f), UnityEngine.Random.Range(-40f, 40f), UnityEngine.Random.Range(-40f, 40f));
}
break;
case TestType.GenericFloats:
cs = new SampleClass[totTweens];
toFloats = new float[totTweens];
for (int i = 0; i < totTweens; ++i) {
SampleClass c = new SampleClass(UnityEngine.Random.Range(-100f, 100f));
cs[i] = c;
toFloats[i] = UnityEngine.Random.Range(-100f, 100f);
}
break;
}
yield return null;
// Prepare and start engine
float time;
switch (engineType) {
case EngineType.DOTween:
testTitle += " v" + DOTween.Version;
concludeTest = DOTweenTester.Conclude;
DOTween.Init(true, false);
DOTween.SetTweensCapacity(totTweens, 0);
yield return null;
// Start
time = Time.realtimeSinceStartup;
if (testType == TestType.Transforms) DOTweenTester.Start(ts, toPositions);
else DOTweenTester.Start(cs, toFloats);
startupTime = Time.realtimeSinceStartup - time;
break;
case EngineType.HOTween:
testTitle += " v" + HOTween.VERSION;
concludeTest = HOTweenTester.Conclude;
HOTween.Init(true, false, false);
yield return null;
// Start
time = Time.realtimeSinceStartup;
if (testType == TestType.Transforms) HOTweenTester.Start(ts, toPositions);
else HOTweenTester.Start(cs, toFloats);
startupTime = Time.realtimeSinceStartup - time;
break;
case EngineType.LeanTween:
concludeTest = LeanTweenTester.Conclude;
LeanTween.init(totTweens + 1);
yield return null;
// Start
time = Time.realtimeSinceStartup;
if (testType == TestType.Transforms) LeanTweenTester.Start(gos, toPositions);
else LeanTweenTester.Start(this.gameObject, cs, toFloats);
startupTime = Time.realtimeSinceStartup - time;
break;
case EngineType.GoKit:
concludeTest = GoKitTester.Conclude;
yield return null;
// Start
time = Time.realtimeSinceStartup;
if (testType == TestType.Transforms) GoKitTester.Start(ts, toPositions);
else GoKitTester.Start(cs, toFloats);
startupTime = Time.realtimeSinceStartup - time;
break;
case EngineType.iTween:
concludeTest = iTweenTester.Conclude;
yield return null;
// Start
time = Time.realtimeSinceStartup;
if (testType == TestType.Transforms) iTweenTester.Start(gos, toPositions);
else iTweenTester.Start(this.gameObject, cs, toFloats);
startupTime = Time.realtimeSinceStartup - time;
break;
}
testTitle += " (startup time: " + startupTime + ")";
yield return null;
state = State.Executing;
fpsGadget.ResetFps();
}
public static void Start(SampleClass[] cs, float[] to)
{
GoTweenConfig goConfig = new GoTweenConfig().setEaseType(GoEaseType.QuadInOut).setIterations(-1, GoLoopType.PingPong);
for (int i = 0; i < cs.Length; ++i) {
goConfig.clearProperties();
goConfig.floatProp("floatVal", to[i]);
Go.to(cs[i], 1, goConfig);
}
}
public static void Start(GameObject target, SampleClass[] cs, float[] to)
{
for (int i = 0; i < cs.Length; ++i) {
SampleClass c = cs[i];
LeanTween.value(target, x=> c.floatVal = x, c.floatVal, to[i], 1).setEase(LeanTweenType.easeInOutQuad).setRepeat(-1).setLoopType(LeanTweenType.pingPong);
}
}
public static void Start(SampleClass[] cs, float[] to)
{
Holoville.HOTween.TweenParms tp = new Holoville.HOTween.TweenParms().Ease(EaseType.EaseInOutQuad).Loops(-1, Holoville.HOTween.LoopType.Yoyo);
for (int i = 0; i < cs.Length; ++i) {
HOTween.To(cs[i], 1, tp.NewProp("floatVal", to[i]));
}
}
private static MetaDataWrapper<SampleClass> CreateObjectToTransform()
{
var objectToTransform = new SampleClass
{
Id = 1,
SomeValue = "Somevalue text test string",
DateTime = DateTime.UtcNow,
NotMappedValue = "Should be not mapped"
};
return new MetaDataWrapper<SampleClass>(objectToTransform);
}
public void save_XML()
{
string fileName = @"config.xml";
SampleClass obj = new SampleClass();
SampleClass obj2 = new SampleClass();
obj.Message = "テストです。";
obj.Number = 123;
obj2.Message = "二段階構造!";
obj2.Number = 4141;
obj.sp = obj2;
XmlSerializer serializer = new XmlSerializer(typeof(SampleClass));
FileStream fs = new FileStream(fileName, FileMode.Create);
serializer.Serialize(fs, obj);
fs.Close();
}
public static void Start(SampleClass[] cs, float[] to)
{
for (int i = 0; i < cs.Length; ++i) {
SampleClass c = cs[i];
DOTween.To(()=> c.floatVal, x=> c.floatVal = x, to[i], 1).SetEase(Ease.InOutQuad).SetLoops(-1, DG.Tweening.LoopType.Yoyo);
}
}
public static void Start(GameObject target, SampleClass[] cs, float[] to)
{
for (int i = 0; i < cs.Length; ++i) {
SampleClass c = cs[i];
Hashtable hs = new Hashtable();
hs.Add("from", c.floatVal);
hs.Add("to", to[i]);
hs.Add("time", 1);
hs.Add("onupdate", "UpdateiTweenFloat");
hs.Add("looptype", iTween.LoopType.pingPong);
hs.Add("easetype", iTween.EaseType.easeInOutQuad);
iTween.ValueTo(target, hs);
}
}
