public SyncFileTarget(IFormatter formatter, string logFilePath, bool autoFlush = false)
: base(formatter)
{
_logFilePath = logFilePath;
_logFileDirectory = Path.GetDirectoryName(logFilePath);
if (!string.IsNullOrEmpty(_logFileDirectory))
Directory.CreateDirectory(_logFileDirectory);
if (File.Exists(logFilePath))
{
File.Delete(logFilePath);
}
try
{
var file = File.Open(logFilePath, FileMode.Create, FileAccess.Write, FileShare.Read);
_writer = new StreamWriter(file, Encoding.UTF8);
_writer.AutoFlush = autoFlush;
}
catch (IOException)
{
_writer = StreamWriter.Null;
}
}
public BaseLanguageWriter(ILanguage language, IFormatter formatter, IExceptionFormatter exceptionFormatter, bool writeExceptionsAsComments)
{
this.Language = language;
this.formatter = formatter;
this.exceptionFormatter = exceptionFormatter;
this.WriteExceptionsAsComments = writeExceptionsAsComments;
}
public FileStorage( string path )
{
// Open the file
file = new FileStream(path, FileMode.OpenOrCreate);
// Create the info object
info = new FileInfo(path);
lastLength = info.Length;
try
{
// Check for read & write ability
if( !(file.CanRead && file.CanWrite) )
throw new IOException("File filePath could not be opened for both read & write.");
// Create our formatter
formatter = new BinaryFormatter();
InitializeDataStructures();
}
finally
{
file.Close();
}
}
public DropCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("drop");
AddCommandName("putdown");
AddCommandName("release");
}
private static void Print(IFormatter formatter)
{
List<Publication> documents = new List<Publication>();
var newspaper = new Newspaper(formatter);
newspaper.Title = "The Publicist";
newspaper.Articles.Add("Sugar linked to bad eyesight", "Rod Sugar");
newspaper.Articles.Add("Sweden bans chocolate", "Willy Wonka");
newspaper.Articles.Add("Opera house to be painted orange", "Orange Arup");
documents.Add(newspaper);
var book = new Book(formatter)
{
Title = "Price of Silence",
Author = "Jay and Silent Bob",
Text = "Blah-de-blah-de-blah..."
};
documents.Add(book);
var magazine = new Magazine(formatter)
{
Name = "MixMag",
PrintDate = "30/08/1993",
CoverHeadline = "Downloads outstrip CD sales"
};
documents.Add(magazine);
foreach (var doc in documents)
{
doc.Print();
}
}
public void Before_Each_Test()
{
console = MockRepository.GenerateMock<IConsoleFacade>();
repository = MockRepository.GenerateMock<IRepository<GameObject>>();
format = new Formatter(console, repository);
cmd = new DescribeCommand(console, repository, format);
}
private static string BuildFormatTimePart(IFormatter cultureFormatter, TimeUnit timeUnitType, int amountOfTimeUnits)
{
// Always use positive units to account for negative timespans
return amountOfTimeUnits != 0
? cultureFormatter.TimeSpanHumanize(timeUnitType, Math.Abs(amountOfTimeUnits))
: null;
}
public RunnerInvocation(string dll, string tags, IFormatter formatter, bool failFast)
{
this.dll = dll;
this.failFast = failFast;
Tags = tags;
Formatter = formatter;
}
public FileModel(FileAndType ft, object content, FileAndType original = null, IFormatter serializer = null)
{
OriginalFileAndType = original ?? ft;
FileAndType = ft;
_content = content;
_serializer = serializer;
}
private NetworkRecieverActor(Actor Reciever, bool IsServer)
{
this.formatter = new BinaryFormatter();
this.IsServer = IsServer;
if(Reciever is RecieverActor)
this.Reciever = (RecieverActor)Reciever;
}
public InventoryCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("inventory");
AddCommandName("inv");
AddCommandName("i");
}
public StreamJournalWriter(IStore storage, EngineConfiguration config)
{
_config = config;
_storage = storage;
_journalFormatter = config.CreateFormatter(FormatterUsage.Journal);
_rolloverStrategy = _config.CreateRolloverStrategy();
}
public TakeCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("take");
AddCommandName("pickup");
AddCommandName("get");
}
public override void Write(Entry entry, IFormatter formatter)
{
lock (typeof (ColoredConsoleTarget))
{
var oldColor = Console.ForegroundColor;
switch (entry.Level)
{
case LogLevel.Warn:
Console.ForegroundColor = ConsoleColor.DarkYellow;
break;
case LogLevel.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogLevel.Fatal:
Console.ForegroundColor = ConsoleColor.Magenta;
break;
}
var content = (Formatter ?? formatter).Format(entry);
Console.Write(content);
Console.ForegroundColor = oldColor;
}
}
public SimpleIterativeRouter2(Key self, ushort tcpPort, IMessagingSocket sock, IKeyBasedRoutingAlgorithm algo, IFormatter formatter, bool isStrictMode)
{
_selfId = self;
_tcpPort = tcpPort;
_sock = sock;
_algo = algo;
_strict_mode = isStrictMode;
// メッセージに含むことの出来る大体の最大NodeHandle数を計算
int overhead, nodeHandleBytes;
{
using (MemoryStream ms = new MemoryStream ()) {
formatter.Serialize (ms, new NextHopResponse (self, _tcpPort, true, new NodeHandle[0]));
overhead = (int)ms.Length;
}
using (MemoryStream ms = new MemoryStream ()) {
formatter.Serialize (ms, new NodeHandle (self, new IPEndPoint (IPAddress.Loopback, 0), tcpPort));
nodeHandleBytes = (int)ms.Length;
}
}
_maxNodeHandlesPerResponse = (dgramMaxSize - overhead) / nodeHandleBytes;
algo.Setup (self, this);
sock.AddInquiredHandler (typeof (NextHopQuery), MessagingSocket_Inquired_NextHopQuery);
sock.AddInquiredHandler (typeof (CloseNodeQuery), MessagingSocket_Inquired_CloseNodeQuery);
}
public override void Write(Entry entry, IFormatter formatter)
{
var contents = (Formatter ?? formatter).Format(entry);
switch (entry.Level)
{
case LogLevel.Trace:
Log.Verbose(_tag, contents);
break;
case LogLevel.Debug:
Log.Debug(_tag, contents);
break;
case LogLevel.Info:
Log.Info(_tag, contents);
break;
case LogLevel.Warn:
Log.Warn(_tag, contents);
break;
case LogLevel.Error:
Log.Error(_tag, contents);
break;
case LogLevel.Fatal:
Log.WriteLine(LogPriority.Assert, _tag, contents);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public MessageReceiver(TcpClient client, IFormatter formatter, IHandler handler)
{
this.client = client;
this.handler = handler;
this.assembler = new MessageAssembler(formatter);
this.chunk = new byte[4096];
}
static void Serialize(string filename,IFormatter formatter)
{
MyItemType obj = new MyItemType(1, "food");
FileStream fs = new FileStream(filename,FileMode.OpenOrCreate) ;
formatter.Serialize(fs, obj);
fs.Close();
}
public SimpleClient(string IP, int Port)
{
newClient = new TcpClient(IP, Port);
newNetworkStream = newClient.GetStream();
formatter = new BinaryFormatter();
new Thread();
}
/// <inheritdoc />
public string Format(object obj, IFormatter formatter)
{
if (state == null)
state = new ReentranceState();
string result = null;
state.Enter(reentranceCount =>
{
if (reentranceCount >= 3 || state.Visited.Contains(obj))
{
result = "{...}";
}
else
{
try
{
state.Visited.Add(obj);
result = FormatRecursive(obj, formatter);
}
finally
{
state.Visited.Remove(obj);
}
}
});
return result;
}
public LookCommand(IConsoleFacade console, IRepository<GameObject> repository, IFormatter format, IPlayer player)
{
this.console = console;
this.repository = repository;
this.format = format;
this.player = player;
}
public ConsoleTarget(IFormatter formatter)
{
if (formatter == null)
throw new ArgumentNullException("formatter");
Formatter = formatter;
}
public void Run(string dll, string filter, IFormatter outputFormatter, Action<string, string, IFormatter> action)
{
this.dll = dll;
var setup = new AppDomainSetup();
setup.ConfigurationFile = Path.GetFullPath(config);
setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
domain = AppDomain.CreateDomain("NSpecDomain.Run", null, setup);
var type = typeof(Wrapper);
var assemblyName = type.Assembly.GetName().Name;
var typeName = type.FullName;
domain.AssemblyResolve += Resolve;
var wrapper = (Wrapper)domain.CreateInstanceAndUnwrap(assemblyName, typeName);
wrapper.Execute(dll, filter, outputFormatter, action);
AppDomain.Unload(domain);
}
public LogConfig(IFormatter formatter, LogCategoryRegistrar categoryRegistry = null)
{
Formatter = formatter;
CategoryRegistrar = categoryRegistry ?? new LogCategoryRegistrar();
TargetConfigs = new List<TargetConfig>();
Levels = new bool[LogLevels.Levels.Length];
}
HelpPrinter(IFormatter formatter)
{
this.formatter = formatter;
var parser = new Parser();
parser.LoadPlugin(typeof(UnitValue).Assembly);
doc = Documentation.Create(parser.Context);
}
public PickUpCommand(IConsoleFacade console, IRepositoryFactoryFactory factory, IGameObjectQueries goQueries, IFormatter[] formatters)
: base(console, factory, goQueries, formatters)
{
AddCommandName("pickup");
AddCommandName("get");
AddCommandName("grab");
}
/// <summary>
/// Build middle server with a given port.
/// </summary>
/// <param name="port"></param>
public UniVRPNityServer(int port = Network.UniVRPNityServerDefaultPort,
bool verbose = true,
int updateInterval = DefaultUpdateInterval)
{
Console.WriteLine("==== UniVRPNity middle server ====");
formatter = new BinaryFormatter();
remotes = new VrpnObjects();
this.verbose = verbose;
this.updateInterval = updateInterval;
//Create a socket for listening connections
middleServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
IPEndPoint ipLocal = new IPEndPoint(IPAddress.Loopback, port);
try
{
middleServer.Bind(ipLocal);
Console.WriteLine("\r Running on port " + port);
//Run server
StartListening();
}
catch (SocketException)
{
Console.Error.WriteLine("Error : Cannot reach " + ipLocal.ToString() + " address at port " + port);
Console.Error.WriteLine("An other application is probably using this port.");
Console.ReadKey();
}
}
public IPort Bind(int portNumber, IFormatter formatter)
{
TcpPort port = new TcpPort(portNumber, formatter);
port.Open();
ports.Add(port);
return port;
}
public Message(byte[] chunk, int chunkSize, int offset, IFormatter formatter)
{
this.chunk = chunk;
this.chunkSize = chunkSize;
this.offset = offset;
this.formatter = formatter;
}
/// <inheritdoc />
public virtual string Format(object obj, IFormatter formatter)
{
var value = (Type) obj;
var result = new StringBuilder();
AppendType(result, value);
return result.ToString();
}
public void Serialize <T>(IFormatter f, JsonSchemaValidationContext c, T o)
{
GenericSerializer <T> .Serialize(this, f, c, o);
}
public void ToJsonScheama(IFormatter f)
{
f.Key("type"); f.Value("object");
}
public Internal(IFormatter formatter)
: base(formatter)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleExpressionBinding"/> class.
/// </summary>
/// <param name="sourceExpression">
/// The source expression.
/// </param>
/// <param name="targetExpression">
/// The target expression.
/// </param>
/// <param name="formatter">
/// The formatter to use.
/// </param>
public SimpleExpressionBinding(string sourceExpression, string targetExpression, IFormatter formatter)
: base(formatter)
{
this.sourceExpression = Expression.Parse(sourceExpression);
this.targetExpression = Expression.Parse(targetExpression);
}
public bool TryGetFormatter(Type type, FormatterLocationStep step, ISerializationPolicy policy, out IFormatter formatter)
{
if (!type.IsArray)
{
formatter = null;
return(false);
}
if (type.GetArrayRank() == 1)
{
if (FormatterUtilities.IsPrimitiveArrayType(type.GetElementType()))
{
formatter = (IFormatter)Activator.CreateInstance(typeof(PrimitiveArrayFormatter <>).MakeGenericType(type.GetElementType()));
}
else
{
formatter = (IFormatter)Activator.CreateInstance(typeof(ArrayFormatter <>).MakeGenericType(type.GetElementType()));
}
}
else
{
formatter = (IFormatter)Activator.CreateInstance(typeof(MultiDimensionalArrayFormatter <,>).MakeGenericType(type, type.GetElementType()));
}
return(true);
}
public void Serialize <T>(IFormatter f, JsonSchemaValidationContext c, T o)
{
f.Serialize(GenericCast <T, int> .Cast(o));
}
public void ToJsonSchema(IFormatter f)
{
f.Key("type"); f.Value("integer");
}
public ReferenceFormatter(CerasSerializer serializer)
{
_serializer = serializer;
_typeFormatter = (IFormatter <Type>)serializer.GetSpecificFormatter(typeof(Type));
}
public FileModel(FileAndType ft, object content, FileAndType original = null, IFormatter serializer = null)
{
OriginalFileAndType = original ?? ft;
if (OriginalFileAndType.File.StartsWith("~/"))
{
Key = OriginalFileAndType.File;
}
else
{
Key = "~/" + OriginalFileAndType.File;
}
FileAndType = ft;
ModelWithCache = new ModelWithCache(content, serializer);
}
public FileStorage(string folderName, string fileName, IFormatter formatter)
{
FolderName = folderName;
FileName = fileName;
Formatter = formatter;
}
protected SelectFormatter(IFormatter <TInner> innerSerializer, bool mapForSize = false)
{
_innerSerializer = innerSerializer;
_mapForSize = mapForSize;
}
public Book(IFormatter formatter)
: base(formatter)
{
}
public FileDataService()
{
this.formatter = new BinaryFormatter();
}
public SelectFuncFormatter(IFormatter <TInner> innerSerializer, Func <TOuter, TInner> toInner, Func <TInner, TOuter> toOuter, bool mapForSize = false) :
base(innerSerializer, mapForSize)
{
_toInner = toInner;
_toOuter = toOuter;
}
public PokingServer(int port, object reactingObject, IFormatter formatter = null, ILogger logger = null, bool useCompression = false)
: base(new IPEndPoint(IPAddress.Any, port), formatter, logger, useCompression)
{
this.reactingObject = reactingObject;
}
public FileDataService(IFormatter formatter)
{
this.formatter = formatter;
}
public SerializationBLL()
: base()
{
m_Formatter = new BinaryFormatter();
}
/// <summary>
/// Creates new instance.
/// </summary>
/// <param name="eventStore">The underlaying event store.</param>
/// <param name="commandStore">The underlaying command store.</param>
/// <param name="eventFormatter">The formatter for serializing event payloads.</param>
/// <param name="commandFormatter">The formatter for serializing commands.</param>
/// <param name="factory">The process root factory.</param>
/// <param name="eventDispatcher">The dispatcher for newly created events in the processes.</param>
/// <param name="commandDispatcher">The dispatcher for newly created commands in the processes.</param>
/// <param name="snapshotProvider">The snapshot provider.</param>
/// <param name="snapshotStore">The store for snapshots.</param>
public ProcessRootRepository(IEventStore eventStore, ICommandStore commandStore, IFormatter eventFormatter, ISerializer commandFormatter,
IAggregateRootFactory <T> factory, IEventDispatcher eventDispatcher, ICommandDispatcher commandDispatcher, ISnapshotProvider snapshotProvider, ISnapshotStore snapshotStore)
: base(eventStore, eventFormatter, factory, eventDispatcher, snapshotProvider, snapshotStore)
{
Ensure.NotNull(commandStore, "commandStore");
Ensure.NotNull(commandDispatcher, "commandDispatcher");
Ensure.NotNull(commandFormatter, "commandFormatter");
this.commandStore = commandStore;
this.commandFormatter = commandFormatter;
this.commandDispatcher = commandDispatcher;
}
public void AddFormatter(IFormatter <Tinput> formatter)
{
}
public FileNotifier(IFormatter formatter, Func <Counterexample, string> pathGenerator)
: base(formatter)
{
_pathGenerator = pathGenerator;
}
///<summary>
/// Creates a new instance of this HasTextFilteringFormatter.
///</summary>
/// <param name="defaultValue">the default value to be returned, if input text doesn't contain text</param>
///<param name="underlyingFormatter">an optional underlying formatter</param>
/// <remarks>
/// If no underlying formatter is specified, the values
/// get passed through "as-is" after being filtered
/// </remarks>
public HasTextFilteringFormatter(string defaultValue, IFormatter underlyingFormatter)
: base(underlyingFormatter)
{
_defaultValue = defaultValue;
}
public void DeleteFormatter(IFormatter <Tinput> formatter)
{
}
public PokingClientConnection(object reactingObject, IFormatter customFormatter = null, ILogger logger = null, bool useCompression = false)
: base(customFormatter, logger, useCompression)
{
Reactor = new Reactor(this, reactingObject);
}
/// <summary>
/// Initializes a new message.
/// </summary>
/// <param name="name">The name of the message.</param>
/// <param name="payload">The payload of the message.</param>
/// <param name="formatter">The payload serializer.</param>
/// <param name="type">MIME type of the message.</param>
public Message(string name, T payload, IFormatter <T> formatter, string?type = null)
: this(name, payload, formatter, new ContentType(type.IfNullOrEmpty(MediaTypeNames.Application.Octet)))
{
}
public void FormatAssociativeTest()
{
IFormatter f = Service <IFormatter> .Instance;
MathSystem s = project.CurrentSystem;
s.RemoveUnusedObjects();
project.Interpret("v1 <- (a+b)+(c+d);");
Signal v1 = s.LookupNamedSignal("v1");
Assert.AreEqual("(a+b)+(c+d)", f.Format(v1, FormattingOptions.Compact), "V1A");
Signal v1S = Std.AutoSimplify(v1);
Assert.AreEqual("a+b+c+d", f.Format(v1S, FormattingOptions.Compact), "V1B");
project.Interpret("v2 <- (a-b)+(c-d);");
Signal v2 = s.LookupNamedSignal("v2");
Assert.AreEqual("(a-b)+(c-d)", f.Format(v2, FormattingOptions.Compact), "V2A");
Signal v2S = Std.AutoSimplify(v2);
Assert.AreEqual("a+-1*b+c+-1*d", f.Format(v2S, FormattingOptions.Compact), "V2B");
project.Interpret("w1 <- (a-b)-(c-d);");
Signal w1 = s.LookupNamedSignal("w1");
Assert.AreEqual("(a-b)-(c-d)", f.Format(w1, FormattingOptions.Compact), "W1A");
Signal w1S = Std.AutoSimplify(w1);
Assert.AreEqual("a+-1*b+-1*c+d", f.Format(w1S, FormattingOptions.Compact), "W1B");
project.Interpret("w2 <- (a+b)-(c+d);");
Signal w2 = s.LookupNamedSignal("w2");
Assert.AreEqual("(a+b)-(c+d)", f.Format(w2, FormattingOptions.Compact), "W2A");
Signal w2S = Std.AutoSimplify(w2);
Assert.AreEqual("a+b+-1*c+-1*d", f.Format(w2S, FormattingOptions.Compact), "W2B");
project.Interpret("x1 <- (a*b)*(c*d);");
Signal x1 = s.LookupNamedSignal("x1");
Assert.AreEqual("(a*b)*(c*d)", f.Format(x1, FormattingOptions.Compact), "X1A");
Signal x1S = Std.AutoSimplify(x1);
Assert.AreEqual("a*b*c*d", f.Format(x1S, FormattingOptions.Compact), "X1B");
project.Interpret("x2 <- (a/b)*(c/d);");
Signal x2 = s.LookupNamedSignal("x2");
Assert.AreEqual("(a/b)*(c/d)", f.Format(x2, FormattingOptions.Compact), "X2A");
Signal x2S = Std.AutoSimplify(x2);
Assert.AreEqual("a*b^(-1)*c*d^(-1)", f.Format(x2S, FormattingOptions.Compact), "X2B");
project.Interpret("y1 <- (a/b)/(c/d);");
Signal y1 = s.LookupNamedSignal("y1");
Assert.AreEqual("(a/b)/(c/d)", f.Format(y1, FormattingOptions.Compact), "Y1A");
Signal y1S = Std.AutoSimplify(y1);
Assert.AreEqual("a*b^(-1)*c^(-1)*d", f.Format(y1S, FormattingOptions.Compact), "Y1B");
project.Interpret("y2 <- (a*b)/(c*d);");
Signal y2 = s.LookupNamedSignal("y2");
Assert.AreEqual("(a*b)/(c*d)", f.Format(y2, FormattingOptions.Compact), "Y2A");
Signal y2S = Std.AutoSimplify(y2);
Assert.AreEqual("a*b*c^(-1)*d^(-1)", f.Format(y2S, FormattingOptions.Compact), "Y2B");
}
///<summary>
/// Creates a new instance of this HasTextFilteringFormatter using null as default value.
///</summary>
///<param name="underlyingFormatter">an optional underlying formatter</param>
/// <remarks>
/// If no underlying formatter is specified, the values
/// get passed through "as-is" after being filtered
/// </remarks>
public HasTextFilteringFormatter(IFormatter underlyingFormatter)
: this(null, underlyingFormatter)
{
}
public Document(IFormatter formatter)
{
this.formatter = formatter;
}
public DefaultConsoleWriter(IFormatter formatter)
{
this.formatter = formatter;
}
private void ParseDataNode(XmlReader reader)
{
string name = reader[ResXResourceWriter.NameStr];
string typeName = reader[ResXResourceWriter.TypeStr];
string mimeTypeName = reader[ResXResourceWriter.MimeTypeStr];
reader.Read();
object value = null;
if (reader.NodeType == XmlNodeType.Element)
{
value = reader.ReadElementString();
}
else
{
value = reader.Value.Trim();
}
if (mimeTypeName != null && mimeTypeName.Length > 0)
{
if (String.Equals(mimeTypeName, ResXResourceWriter.BinSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.Beta2CompatSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.CompatBinSerializedObjectMimeType))
{
string text = (string)value;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (binaryFormatter == null)
{
binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
}
IFormatter formatter = binaryFormatter;
if (serializedData != null && serializedData.Length > 0)
{
value = formatter.Deserialize(new MemoryStream(serializedData));
if (value is ResXNullRef)
{
value = null;
}
}
}
else if (String.Equals(mimeTypeName, ResXResourceWriter.SoapSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.CompatSoapSerializedObjectMimeType))
{
string text = (string)value;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (serializedData != null && serializedData.Length > 0)
{
// Performance : don't inline a new SoapFormatter here. That will always bring in
// the soap assembly, which we don't want. Throw this in another
// function so the class doesn't have to get loaded.
//
IFormatter formatter = CreateSoapFormatter();
value = formatter.Deserialize(new MemoryStream(serializedData));
if (value is ResXNullRef)
{
value = null;
}
}
}
else if (String.Equals(mimeTypeName, ResXResourceWriter.ByteArraySerializedObjectMimeType))
{
if (typeName != null && typeName.Length > 0)
{
Type type = ResolveType(typeName);
if (type != null)
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(byte[])))
{
string text = (string)value;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (serializedData != null)
{
value = tc.ConvertFrom(serializedData);
}
}
}
else
{
Debug.Fail("Could not find type for " + typeName);
// Throw a TypeLoadException here, don't silently
// eat this info. ResolveType failed, so
// Type.GetType should as well.
Type.GetType(typeName, true);
}
}
}
}
else if (typeName != null && typeName.Length > 0)
{
Type type = ResolveType(typeName);
if (type != null)
{
if (type == typeof(ResXNullRef))
{
value = null;
}
else if (typeName.IndexOf("System.Byte[]") != -1 && typeName.IndexOf("mscorlib") != -1)
{
// Handle byte[]'s, which are stored as base-64 encoded strings.
// We can't hard-code byte[] type name due to version number
// updates & potential whitespace issues with ResX files.
value = FromBase64WrappedString((string)value);
}
else
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(string)))
{
string text = (string)value;
value = tc.ConvertFromInvariantString(text);
}
else
{
Debug.WriteLine("Converter for " + type.FullName + " doesn't support string conversion");
}
}
}
else
{
Debug.Fail("Could not find type for " + typeName);
// Throw a TypeLoadException for this type which we
// couldn't load to include fusion binding info, etc.
Type.GetType(typeName, true);
}
}
else
{
// if mimeTypeName and typeName are not filled in, the value must be a string
Debug.Assert(value is string, "Resource entries with no Type or MimeType must be encoded as strings");
}
if (name == null)
{
throw new ArgumentException(SR.GetString(SR.InvalidResXResourceNoName, value));
}
resData[name] = value;
}
public bool TryGetFormatter(Type type, FormatterLocationStep step, ISerializationPolicy policy, out IFormatter formatter)
{
if (!typeof(Delegate).IsAssignableFrom(type))
{
formatter = null;
return(false);
}
formatter = (IFormatter)Activator.CreateInstance(typeof(DelegateFormatter <>).MakeGenericType(type));
return(true);
}
