public Client(String address, int port)
{
serverAddress = address;
serverPort = port;
tcpClient = new TcpClient();
serializer = new FileSerializer();
}
/// <summary>
/// Initializes a new instance of <see cref="HSSettingsManager"/> class
/// </summary>
/// <param name="settingsFilePath">Path to the settings file</param>
public HSSettingsManager(string settingsFilePath, IFileSerializer fileSerializer, IMetaPubSub metaMessenger)
: base(settingsFilePath, fileSerializer)
{
_metaMessenger = metaMessenger;
this.SettingsChanged += HSSettingsManager_SettingsChanged;
}
public Client()
{
serverAddress = "127.0.0.1";
serverPort = 13000;
tcpClient = new TcpClient();
serializer = new FileSerializer();
}
/// <summary>
/// Initializes a new instance of the <see cref="FileService"/> class.
/// </summary>
/// <param name="uow">UnitOfWork implementation</param>
/// <param name="serializer">File serializer implementation</param>
public FileService(
IUnitOfWork uow,
IFileSerializer serializer)
{
this._uow = uow;
this._defaultFileSerializer = serializer;
}
public Server(String address, int port)
{
this.port = port;
serverAddress = IPAddress.Parse(address);
server = new TcpListener(serverAddress, port);
serializer = new FileSerializer();
server.Start();
}
public Program(
ITestingDataDirectoryContentPathsProvider testingDataDirectoryContentPathsProvider,
ITemporaryDirectoryFilePathProvider temporaryDirectoryFilePathProvider,
IFileSerializer <List <string> > linesTextFileSerializer)
{
this.TestingDataDirectoryContentPathsProvider = testingDataDirectoryContentPathsProvider;
this.TemporaryDirectoryFilePathProvider = temporaryDirectoryFilePathProvider;
this.LinesTextFileSerializer = linesTextFileSerializer;
}
public RoundTripFileSerializationVerifier(
IHumanOutput humanOutput,
IFileSerializer <T> fileSerializer,
IFileEqualityComparer fileEqualityComparer,
IValueEqualityComparer <T> valueEqualityComparer)
{
this.HumanOutput = humanOutput;
this.FileSerializer = fileSerializer;
this.FileEqualityComparer = fileEqualityComparer;
this.ValueEqualityComparer = valueEqualityComparer;
}
public WatchingSettingsManager(string settingsFilePath, IFileSerializer fileSerializer)
: base(settingsFilePath, fileSerializer)
{
_watcher = new FileSystemWatcher();
_watcher.Path = Path.GetDirectoryName(settingsFilePath);
_watcher.Filter = Path.GetFileName(settingsFilePath);
_watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Attributes | NotifyFilters.CreationTime;
_watcher.Changed += Watcher_OnChanged;
_watcher.Deleted += Watcher_OnChanged;
_watcher.Renamed += Watcher_OnChanged;
}
public MessengerWrapper(IMessengerConfiguration configuration, IFileSerializer serializer)
{
this.configuration = configuration;
this.serializer = serializer;
messenger = new BaseClient
{
On2FACodeCallback = OnTwoFactorRequestedAsync,
FbEventCallback = OnFbEventCallback,
DeleteCookiesCallback = OnDeleteCookiesCallback,
ReadCookiesFromDiskCallback = OnReadCookiesFromDiskCallback,
WriteCookiesToDiskCallback = OnWriteCookiesToDiskCallback
};
}
public FileSystemListener(FileSystemListenerOptions options, IFileSerializer <T> serializer, ILogger <FileSystemListener <T> > logger)
{
_options = options;
_logger = logger;
_serializer = serializer;
_status = false;
if (!Directory.Exists(_options.Folder))
{
Directory.CreateDirectory(_options.Folder);
}
if (!Directory.Exists(_options.CompletedFolder))
{
Directory.CreateDirectory(_options.CompletedFolder);
}
}
protected override bool ValidatePlugin(IFileSerializer <T> serializer)
{
if (String.IsNullOrEmpty(serializer.FileExtension) ||
String.IsNullOrEmpty(serializer.FileTypeFilter))
{
// extention filter string, too many bar characters
return(false);
}
var numOfBarChars = serializer.FileTypeFilter.Count(x => x == '|');
if (numOfBarChars != 1)
{
// too many bar characters
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="cacheRoot">The cache's root file path.</param>
/// <param name="serializer">Serializer instance used to serialize and deserializer cache items.</param>
/// <param name="calculateCacheSize">If true, will calculate the cache's current size upon new object creation.
/// Turned off by default as directory traversal is somewhat expensive and may not always be necessary based on use case.
/// </param>
public NFileCache(string cacheRoot, IFileSerializer serializer, bool calculateCacheSize = false)
{
Interlocked.Increment(ref _nameCounter);
_serializer = serializer;
if (cacheRoot == null || !Path.IsPathRooted(cacheRoot))
{
CacheDir = Path.Combine(Directory.GetCurrentDirectory(), cacheRoot ?? DefaultCacheFolderName);
}
else
{
CacheDir = cacheRoot;
}
DefaultRegion = null;
if (calculateCacheSize)
{
CurrentCacheSize = GetCacheSize();
}
MaxCacheSizeReached += NFileCache_MaxCacheSizeReached;
}
/// <inheritdoc/>
public void ReadFromFile(string fileName, IFileSerializer serializer = null)
{
var fileSerializer = serializer ?? _defaultFileSerializer;
var folderName = "storage";
Directory.CreateDirectory(folderName);
var books = fileSerializer.Read <Book>($"{folderName}/{fileName}_books.{fileSerializer.Name}");
_uow.BookRepository.CreateMany(books);
var clients = fileSerializer.Read <Client>($"{folderName}/{fileName}_client.{fileSerializer.Name}");
_uow.ClientRepository.CreateMany(clients);
var comments = fileSerializer.Read <Comment>($"{folderName}/{fileName}_comment.{fileSerializer.Name}");
_uow.CommentRepository.CreateMany(comments);
var wishList = fileSerializer.Read <Wish>($"{folderName}/{fileName}_wishList.{fileSerializer.Name}");
_uow.WishListRepository.CreateMany(wishList);
}
/// <inheritdoc/>
public void SaveToFile(string fileName, IFileSerializer serializer = null)
{
var fileSerializer = serializer ?? _defaultFileSerializer;
var folderName = "storage";
Directory.CreateDirectory(folderName);
var books = _uow.BookRepository.Get();
fileSerializer.Write(books, $"{folderName}/{fileName}_books.{fileSerializer.Name}");
var clients = _uow.ClientRepository.Get();
fileSerializer.Write(clients, $"{folderName}/{fileName}_clients.{fileSerializer.Name}");
var comments = _uow.CommentRepository.Get();
fileSerializer.Write(comments, $"{folderName}/{fileName}_comments.{fileSerializer.Name}");
var wishList = _uow.WishListRepository.Get();
fileSerializer.Write(wishList, $"{folderName}/{fileName}_wishList.{fileSerializer.Name}");
}
public FileRepository(T item, IFileSerializer <T> serializer, IFileDialog dialog) : this(serializer, dialog)
{
Item = item;
_orginal = Activator.CreateInstance <T>();
PropertyMapper.Instance.MapProperties(Item, _orginal, false);
}
/// <summary>
/// Initializes a new instance of <see cref="SettingsManager"/> class
/// </summary>
/// <param name="settingsFilePath">Path to the settings file</param>
public SettingsManager(string settingsFilePath, IFileSerializer fileSerializer)
{
SettingsFilePath = settingsFilePath;
this.fileSerializer = fileSerializer;
}
public void Setup()
{
this._unitOfWorkFake = A.Fake <IUnitOfWork>();
this.fileSerializer = A.Fake <IFileSerializer>();
}
private SettingsManager <TestSettings> SetupSettingsManager(IFileSerializer fileSerializer)
{
return(new SettingsManager <TestSettings>(GetAbsoluteFormattedPath(), fileSerializer));
}
static Program()
{
_serviceProvider = Mapper.Map();
_departmentService = _serviceProvider.GetService <IDepartmentService>();
_fileSerializer = _serviceProvider.GetService <IFileSerializer>();
}
public FileSystemPublisher(FileSystemListenerOptions options, IFileSerializer <T> serializer)
{
_options = options;
_serializer = serializer;
}
public FileSystemListener(IOptions <FileSystemListenerOptions> options, IFileSerializer <T> serializer, ILogger <FileSystemListener <T> > logger)
: this(options.Value, serializer, logger)
{
}
public FileSystemPublisher(IOptions <FileSystemListenerOptions> options, IFileSerializer <T> serializer)
: this(options.Value, serializer)
{
}
/// <summary>
/// Load element values into the ProteinDictionary and return an <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing ProteinLoadInfo which details how the ProteinDictionary was changed.
/// </summary>
/// <param name="fileName">File name to load into the dictionary.</param>
/// <param name="serializer">Serializer used to load the file.</param>
/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing ProteinLoadInfo which details how the ProteinDictionary was changed.</returns>
public IEnumerable <ProteinLoadInfo> Load(string fileName, IFileSerializer <List <Protein> > serializer)
{
return(Load(serializer.Deserialize(fileName)));
}
public VisualStudioSolutionFileSerializer(IFileSerializer <SolutionFile> fileSerializer)
: base(fileSerializer)
{
}
public FileRepository(IFileSerializer <T> serializer, IFileDialog dialog)
{
_serializer = serializer;
_dialog = dialog;
}
/// <summary>
/// Creates an instance of the cache.
/// </summary>
/// <param name="serializer">Serializer instance used to serialize and deserializer cache items.</param>
/// <param name="calculateCacheSize">If true, will calculate the cache's current size upon new object creation.
/// Turned off by default as directory traversal is somewhat expensive and may not always be necessary based on use case.
/// </param>
public NFileCache(IFileSerializer serializer, bool calculateCacheSize = false)
: this(null, serializer, calculateCacheSize)
{
}
public void WriteFile(IFileSerializer fileSerializer, List <TraceResult.ThreadResult> list)
{
Console.WriteLine(fileSerializer.Serialize(list));
}
public SignalViewModel()
{
SignalData = new FunctionData();
fileDialog = new FileDialogWpf();
serializer = new FileBinarySerializer();
}
