private void ImportSettingsMenu_Click(object sender, RoutedEventArgs args)
{
using var ofd = new OpenFileDialog
{
FileName = BackupSettings.FileName,
Filter = $"{nameof(BackupSettings)} files(*{DataFileWriter.JsonExtension})|*{DataFileWriter.JsonExtension}",
CheckFileExists = true,
InitialDirectory = Path.Combine(Settings.Default.AppDataPath,
DataFileWriter.ParentDirectoryName),
};
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
try
{
_importedSettings = DataFileWriter.Read <BackupSettings>(ofd.FileName);
}
catch (Exception e)
{
Logger.Error(e, "設定のインポートに失敗しました。");
_importedSettings = null;
}
if (_importedSettings is null)
{
MessageBox.Show("インポートに失敗しました。", $"{App.AssemblyName.Name} - エラー", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (_importedSettings.IsDefault)
{
MessageBox.Show("デフォルト設定がインポートされました。", $"{App.AssemblyName.Name} - 警告", MessageBoxButton.OK, MessageBoxImage.Warning);
}
DiscardImportedSettings.IsEnabled = _importedSettings is not null;
}
}
public override void Output(IRow input, IUnstructuredWriter output)
{
if (_fileWriter == null)
{
_avSchema = Schema.Parse(_avroSchema) as RecordSchema;
var writer = new GenericDatumWriter <GenericRecord>(_avSchema);
_fileWriter = DataFileWriter <GenericRecord> .OpenWriter(writer, output.BaseStream);
}
var record = new GenericRecord(_avSchema);
foreach (var x in input.Schema)
{
var obj = input.Get <object>(x.Name);
if (obj != null)
{
var objType = obj.GetType();
if (objType.IsGenericType && objType.GetGenericTypeDefinition() == typeof(SqlArray <>))
{
obj = ((System.Collections.IEnumerable)obj).Cast <object>().ToArray();
}
}
record.Add(x.Name, obj);
}
_fileWriter.Append(record);
}
public void TestMetaData(string key, object value, Codec.Type codecType, bool useTypeGetter)
{
// create and write out
object[] obj = new object[] { new object[] { "John", 23 } };
IList <Foo> records = MakeRecords(obj);
MemoryStream dataFileOutputStream = new MemoryStream();
Schema schema = Schema.Parse(specificSchema);
DatumWriter <Foo> writer = new SpecificWriter <Foo>(schema);
using (IFileWriter <Foo> dataFileWriter = DataFileWriter <Foo> .OpenWriter(writer, dataFileOutputStream, Codec.CreateCodec(codecType)))
{
SetMetaData(dataFileWriter, key, value);
foreach (Foo rec in records)
{
dataFileWriter.Append(rec);
}
}
MemoryStream dataFileInputStream = new MemoryStream(dataFileOutputStream.ToArray());
// read back
using (IFileReader <Foo> reader = DataFileReader <Foo> .OpenReader(dataFileInputStream))
{
Assert.IsTrue(ValidateMetaData(reader, key, value, useTypeGetter),
string.Format("Error validating header meta data for key: {0}, expected value: {1}", key, value));
}
}
private void CreateAudioVOXFile(bool forceRebuild)
{
List <string> fileListForVox = new List <string>();
string audioVox = GetCompiledPath(AGSEditor.AUDIO_VOX_FILE_NAME);
bool rebuildVox = (!File.Exists(audioVox)) || (forceRebuild);
foreach (AudioClip clip in Factory.AGSEditor.CurrentGame.RootAudioClipFolder.GetAllAudioClipsFromAllSubFolders())
{
if (clip.BundlingType == AudioFileBundlingType.InSeparateVOX)
{
string thisFileName = clip.CacheFileName;
if (File.GetLastWriteTimeUtc(thisFileName) != clip.FileLastModifiedDate)
{
rebuildVox = true;
clip.FileLastModifiedDate = File.GetLastWriteTimeUtc(thisFileName);
}
fileListForVox.Add(thisFileName);
}
}
if (File.Exists(audioVox) &&
(fileListForVox.Count == 0) || (rebuildVox))
{
File.Delete(audioVox);
}
if ((rebuildVox) && (fileListForVox.Count > 0))
{
DataFileWriter.MakeFlatDataFile(fileListForVox.ToArray(), 0, audioVox, false);
}
}
public override bool Build(CompileMessages errors, bool forceRebuild)
{
if (!base.Build(errors, forceRebuild))
{
return(false);
}
Factory.AGSEditor.SetMODMusicFlag();
DeleteAnyExistingSplitResourceFiles();
if (!DataFileWriter.SaveThisGameToFile(AGSEditor.COMPILED_DTA_FILE_NAME, Factory.AGSEditor.CurrentGame, errors))
{
return(false);
}
string errorMsg = DataFileWriter.MakeDataFile(ConstructFileListForDataFile(errors),
Factory.AGSEditor.CurrentGame.Settings.SplitResources * 1000000,
Factory.AGSEditor.BaseGameFileName, true);
if (errorMsg != null)
{
errors.Add(new CompileError(errorMsg));
}
File.Delete(AGSEditor.COMPILED_DTA_FILE_NAME);
CreateAudioVOXFile(forceRebuild);
// Update config file with current game parameters
Factory.AGSEditor.WriteConfigFile(GetCompiledPath());
return(true);
}
public async Task GetWriterSuccessTest()
{
//Arrange
var model = new Model()
{
LastName = "lastname",
FirstName = "firstname",
Gender = "gender",
FavoriteColor = "favoritecolor",
DateOfBirth = DateTime.Today
};
StringBuilder sb = new StringBuilder();
sb.AppendLine($"{model.LastName},{model.FirstName},{model.Gender},{model.FavoriteColor},{model.DateOfBirth.ToShortDateString()}");
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString()));
Mock <IFileStreamWriter> fileStreamWriter = new Mock <IFileStreamWriter>();
fileStreamWriter.Setup(m => m.GetWriter(It.IsAny <FileInfo>())).Returns(new StreamWriter(memoryStream));
var dataFileWriter = new DataFileWriter(fileStreamWriter.Object);
//Act
bool didItWrite = await dataFileWriter.WriteModelToFile(model, null);
//Assert
Assert.IsTrue(didItWrite);
}
private void UploadFileToBlobStorage(string blobAddress, Stream file)
{
var writer = new DataFileWriter();
writer.SetContentStream(file);
writer.Write(DataFileBlobContainer, blobAddress);
}
private void serializeAvro <T>(MemoryStream dataStream, List <SingleColumnPoco <T> > data, string schema)
{
var avroSchema = Schema.Parse(schema);
var recordSchema = avroSchema as RecordSchema;
Debug.Assert(recordSchema != null, "recordSchema != null");
var writer = new GenericWriter <GenericRecord>(avroSchema);
var fileWriter = DataFileWriter <GenericRecord> .OpenWriter(writer, dataStream);
var encoder = new BinaryEncoder(dataStream);
foreach (SingleColumnPoco <T> record in data)
{
var genericRecord = new GenericRecord(recordSchema);
genericRecord.Add("Value", record.Value);
// some tests use value2 field
if (recordSchema.Fields.Exists(x => x.Name == "Value2"))
{
genericRecord.Add("Value2", 0);
}
fileWriter.Append(genericRecord);
}
fileWriter.Flush();
dataStream.Seek(0, SeekOrigin.Begin);
}
// Disabled due to long runtime [TestCase(specificSchema, Codec.Type.Deflate, 1000, 588, 998)]
public void TestSyncAndSeekPositions(string schemaStr, Codec.Type codecType, int iterations, int firstSyncPosition, int secondSyncPosition)
{
// create and write out
IList <Foo> records = MakeRecords(GetTestFooObject());
MemoryStream dataFileOutputStream = new MemoryStream();
Schema schema = Schema.Parse(schemaStr);
DatumWriter <Foo> writer = new SpecificWriter <Foo>(schema);
using (IFileWriter <Foo> dataFileWriter = DataFileWriter <Foo> .OpenWriter(writer, dataFileOutputStream, Codec.CreateCodec(codecType)))
{
for (int i = 0; i < iterations; ++i)
{
foreach (Foo foo in records)
{
dataFileWriter.Append(foo);
}
// write out block
if (i == firstSyncPosition || i == secondSyncPosition)
{
dataFileWriter.Sync();
}
}
}
MemoryStream dataFileInputStream = new MemoryStream(dataFileOutputStream.ToArray());
// read syncs
IList <long> syncs = new List <long>();
using (IFileReader <Foo> reader = DataFileReader <Foo> .OpenReader(dataFileInputStream))
{
long previousSync = -1;
foreach (Foo foo in reader.NextEntries)
{
if (reader.PreviousSync() != previousSync &&
reader.Tell() != reader.PreviousSync()) // EOF
{
previousSync = reader.PreviousSync();
syncs.Add(previousSync);
}
}
// verify syncs wth seeks
reader.Sync(0); // first sync
Assert.AreEqual(reader.PreviousSync(), syncs[0],
string.Format("Error syncing reader to position: {0}", syncs[0]));
foreach (long sync in syncs) // the rest
{
reader.Seek(sync);
Foo foo = reader.Next();
Assert.IsNotNull(foo, string.Format("Error seeking to sync position: {0}", sync));
}
}
}
private void CompileTranslation(Translation translation, CompileMessages errors)
{
translation.LoadData();
string compiledFile = Path.Combine(AGSEditor.OUTPUT_DIRECTORY,
Path.Combine(AGSEditor.DATA_OUTPUT_DIRECTORY, translation.CompiledFileName));
Encoding textEncoding = translation.Encoding;
using (BinaryWriter bw = new BinaryWriter(new FileStream(compiledFile, FileMode.Create, FileAccess.Write)))
{
bw.Write(Encoding.ASCII.GetBytes(COMPILED_TRANSLATION_FILE_SIGNATURE));
bw.Write(TRANSLATION_BLOCK_GAME_ID);
byte[] gameName = EncryptStringToBytes(_agsEditor.CurrentGame.Settings.GameName, _agsEditor.CurrentGame.TextEncoding);
bw.Write(gameName.Length + 4 + 4);
bw.Write(_agsEditor.CurrentGame.Settings.UniqueID);
bw.Write(gameName.Length);
bw.Write(gameName);
bw.Write(TRANSLATION_BLOCK_TRANSLATION_DATA);
long offsetOfBlockSize = bw.BaseStream.Position;
bw.Write((int)0); // placeholder for block size, will be filled later
foreach (string line in translation.TranslatedLines.Keys)
{
if (translation.TranslatedLines[line].Length > 0)
{
WriteString(bw, Regex.Unescape(line), textEncoding);
WriteString(bw, Regex.Unescape(translation.TranslatedLines[line]), textEncoding);
}
}
WriteString(bw, string.Empty, textEncoding);
WriteString(bw, string.Empty, textEncoding);
long mainBlockSize = (bw.BaseStream.Position - offsetOfBlockSize) - 4;
bw.Write(TRANSLATION_BLOCK_OPTIONS);
bw.Write((int)12);
bw.Write(translation.NormalFont ?? -1);
bw.Write(translation.SpeechFont ?? -1);
bw.Write((translation.RightToLeftText == true) ? 2 : ((translation.RightToLeftText == false) ? 1 : -1));
bw.Write((int)0); // required for compatibility
DataFileWriter.WriteString(TRANSLATION_BLOCK_STROPTIONS, 16, bw);
var data_len_pos = bw.BaseStream.Position;
bw.Write((long)0); // data length placeholder
bw.Write((int)1); // size of key/value table
DataFileWriter.FilePutString("encoding", bw);
DataFileWriter.FilePutString(translation.EncodingHint, bw);
var end_pos = bw.BaseStream.Position;
var data_len = end_pos - data_len_pos - 8;
bw.Seek((int)data_len_pos, SeekOrigin.Begin);
bw.Write(data_len);
bw.Seek((int)end_pos, SeekOrigin.Begin);
bw.Write(TRANSLATION_BLOCK_END_OF_FILE);
bw.Write((int)0);
bw.Seek((int)offsetOfBlockSize, SeekOrigin.Begin);
bw.Write((int)mainBlockSize);
bw.Close();
}
}
public AvroWriter(IAvroFileValueDef <V> valueDef, FileStream stream, Codec.Type codec) : base(valueDef, stream)
{
Preconditions.CheckArgument(Stream.CanWrite);
var datumWriter = new GenericDatumWriter <GenericRecord>(ValueDef.Schema);
mWriter = DataFileWriter <GenericRecord> .OpenWriter(datumWriter, Stream, Codec.CreateCodec(codec));
Stream.Position = Stream.Length;
}
private void WriteGeneric <T>(Stream output, Schema schema, T value, Codec.Type codecType)
{
DatumWriter <T> writer = new GenericWriter <T>(schema);
using (IFileWriter <T> dataFileWriter = DataFileWriter <T> .OpenWriter(writer, output, Codec.CreateCodec(codecType)))
{
dataFileWriter.Append(value);
}
}
public static void SavePassword(BackupSettings settings, string password)
{
try
{
settings.SetProtectedPassword(password);
DataFileWriter.Write(settings);
}
catch (Exception ex)
{
Logger.Error(ex, "パスワードの保存に失敗");
}
}
private void CreateErrorDownloadFile(EducationSecurityPrincipal user, UploadWizardCompleteModel model)
{
var writer = new DataFileWriter();
model.ErrorDownloadFile = new DownloadFileModel
{
BlobAddress = string.Format("DataFileWizardUploadErrors-{0}-{1}.txt", user.Identity.User.DisplayName, DateTime.Now.Ticks),
FileName = string.Format("{0}-ErrorRows-{1}.txt", user.Identity.User.DisplayName, DateTime.Now.Ticks),
};
writer.BuildTemplate(model.RowErrorValues);
writer.Write(DataFileBlobContainer, model.ErrorDownloadFile.BlobAddress);
}
public void Container_ApacheWriterMicrosoftReader()
{
var serializer = AvroSerializer.Create <ClassOfInt>(new AvroSerializerSettings {
Resolver = new AvroDataContractResolver(true)
});
var schema = ApacheAvro.Schema.Parse(serializer.WriterSchema.ToString()) as ApacheAvro.UnionSchema;
Assert.NotNull(schema);
var recordSchema = schema.Schemas[1] as ApacheAvro.RecordSchema;
Assert.NotNull(recordSchema);
var expected = new List <GenericRecord>();
for (var i = 0; i < 7; i++)
{
var record = new GenericRecord(recordSchema);
record.Add("PrimitiveInt", ClassOfInt.Create(true).PrimitiveInt);
expected.Add(record);
}
using (var memoryStream = new MemoryStream())
{
var datumWriter = new GenericWriter <GenericRecord>(schema);
var writer = DataFileWriter <GenericRecord> .OpenWriter(datumWriter, memoryStream);
writer.WriteHeader();
foreach (var obj in expected)
{
writer.Append(obj);
}
writer.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
var reader = AvroContainer.CreateReader <ClassOfInt>(memoryStream, true, new AvroSerializerSettings {
Resolver = new AvroDataContractResolver(true)
}, new CodecFactory());
var actual = new List <ClassOfInt>();
while (reader.MoveNext())
{
actual.AddRange(reader.Current.Objects);
}
Assert.Equal(expected.Count, actual.Count);
for (var i = 0; i < expected.Count; ++i)
{
Assert.Equal(expected[i]["PrimitiveInt"], actual[i].PrimitiveInt);
}
}
}
private void RebuildVOXFile(string voxFileName, string[] filesOnDisk)
{
Utilities.TryDeleteFile(voxFileName);
if (filesOnDisk.Length > 0)
{
// Register speech assets under names = relative paths inside a Speech folder;
// e.g. Speech/cEgo1.ogg => cEgo1.ogg;
// Speech/French/cEgo1.ogg => French/cEgo1.ogg;
var assets = filesOnDisk.Select(
f => new Tuple <string, string>(f.Substring(SPEECH_DIRECTORY.Length + 1), f)).ToArray();
DataFileWriter.MakeDataFile(assets, 0, voxFileName, false);
}
}
private object CreateDebugFiles(object parameter)
{
Factory.AGSEditor.SetMODMusicFlag();
CompileMessages errors = (parameter as CompileMessages);
if (!DataFileWriter.SaveThisGameToFile(AGSEditor.COMPILED_DTA_FILE_NAME, Factory.AGSEditor.CurrentGame, errors))
{
return(null);
}
Factory.NativeProxy.CreateDebugMiniEXE(new string[] { AGSEditor.COMPILED_DTA_FILE_NAME },
Factory.AGSEditor.BaseGameFileName + ".exe");
File.Delete(AGSEditor.COMPILED_DTA_FILE_NAME);
return(null);
}
public async Task GetWriterFailsTest()
{
//Arrange
Mock <IFileStreamWriter> fileStreamWriter = new Mock <IFileStreamWriter>();
fileStreamWriter.Setup(m => m.GetWriter(It.IsAny <FileInfo>())).Returns <StreamWriter>(null);
var dataFileWriter = new DataFileWriter(fileStreamWriter.Object);
//Act
bool didItWrite = await dataFileWriter.WriteModelToFile(null, null);
//Assert
Assert.IsFalse(didItWrite);
}
[TestCase(specificSchema, Codec.Type.Null, 0, 330)] // 330
public void TestPartialRead(string schemaStr, Codec.Type codecType, int position, int expectedRecords)
{
// create and write out
IList <Foo> records = MakeRecords(GetTestFooObject());
MemoryStream dataFileOutputStream = new MemoryStream();
Schema schema = Schema.Parse(schemaStr);
DatumWriter <Foo> writer = new SpecificWriter <Foo>(schema);
using (IFileWriter <Foo> dataFileWriter = DataFileWriter <Foo> .OpenWriter(writer, dataFileOutputStream, Codec.CreateCodec(codecType)))
{
for (int i = 0; i < 10; ++i)
{
foreach (Foo foo in records)
{
dataFileWriter.Append(foo);
}
// write out block
if (i == 1 || i == 4)
{
dataFileWriter.Sync();
}
}
}
MemoryStream dataFileInputStream = new MemoryStream(dataFileOutputStream.ToArray());
// read back
IList <Foo> readRecords = new List <Foo>();
using (IFileReader <Foo> reader = DataFileReader <Foo> .OpenReader(dataFileInputStream))
{
// move to next block from position
reader.Sync(position);
// read records from synced position
foreach (Foo rec in reader.NextEntries)
{
readRecords.Add(rec);
}
}
Assert.IsTrue((readRecords != null && readRecords.Count == expectedRecords),
string.Format("Error performing partial read after position: {0}", position));
}
private static IEnumerable <ReaderWriterPair <T> > GenericOptions <T>()
{
yield return(new ReaderWriterPair <T>
{
CreateReader = (stream, schema) => DataFileReader <T> .OpenReader(stream, schema),
CreateWriter = (stream, schema, codec) =>
DataFileWriter <T> .OpenWriter(new GenericWriter <T>(schema), stream, codec)
});
yield return(new ReaderWriterPair <T>
{
CreateReader = (stream, schema) => DataFileReader <T> .OpenReader(stream, schema,
(ws, rs) => new GenericDatumReader <T>(ws, rs)),
CreateWriter = (stream, schema, codec) =>
DataFileWriter <T> .OpenWriter(new GenericDatumWriter <T>(schema), stream, codec)
});
}
private void DrawAddButton()
{
//Create a blank line
EditorGUILayout.LabelField("");
if (GUILayout.Button("Add"))
{
if (!m_KeepChanges)
{
//Reset the item values if the user does not want to keep them
ResetValues();
}
//Create and call object that handles the writing
DataFileWriter writer = new DataFileWriter();
writer.WriteToFile(m_FileName, m_ItemID, m_SpawnSecond, m_SliceTimes);
}
}
private static void WriteAndRead <T>(T datum)
where T : ISpecificRecord
{
Console.Write($"{typeof(T).Name}");
try
{
var tempFile = Path.GetTempFileName();
var writer = new SpecificDatumWriter <T>(datum.Schema);
using (var dfw = DataFileWriter <T> .OpenWriter(writer, tempFile))
{
dfw.Append(datum);
}
using (var dfr = DataFileReader <T> .OpenReader(tempFile, datum.Schema))
{
while (dfr.HasNext())
{
var readDatum = dfr.Next();
}
}
var prevColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green;
Console.SetCursorPosition(0, Console.CursorTop);
Console.WriteLine($"✓ {typeof(T).Name}");
Console.ForegroundColor = prevColor;
}
catch (Exception ex)
{
var prevColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.SetCursorPosition(0, Console.CursorTop);
Console.WriteLine($"X {typeof(T).Name}");
Console.ForegroundColor = prevColor;
if (!ex.Message.Contains("Unable to find type "))
{
Console.WriteLine($"Unexpected Exception: {ex.Message}");
}
}
}
public override bool Build(CompileMessages errors, bool forceRebuild)
{
if (!base.Build(errors, forceRebuild))
{
return(false);
}
Factory.AGSEditor.SetMODMusicFlag();
DeleteAnyExistingSplitResourceFiles();
if (Factory.AGSEditor.Preferences.UseLegacyCompiler)
{
Factory.NativeProxy.CompileGameToDTAFile(Factory.AGSEditor.CurrentGame, AGSEditor.COMPILED_DTA_FILE_NAME);
// if using the legacy compiler, make sure engine EXE is copied before calling CreateGameEXE
string newExeName = GetCompiledPath(Factory.AGSEditor.BaseGameFileName + ".exe");
string sourceEXE = Path.Combine(Factory.AGSEditor.EditorDirectory, AGSEditor.ENGINE_EXE_FILE_NAME);
File.Copy(sourceEXE, newExeName, true);
BuildTargetWindows targetWindows = (BuildTargetsInfo.FindBuildTargetByName("Windows") as BuildTargetWindows);
// updating the Vista game explorer resources after the EXE is fully created is deleting the data file,
// corrupting the game resources
targetWindows.UpdateWindowsEXE(newExeName, errors);
// the above all needs to be done here anyway, so finish up by creating the setup EXE and copying plugins
targetWindows.CreateCompiledSetupProgram();
targetWindows.CopyPlugins(errors);
Factory.NativeProxy.CreateGameEXE(ConstructFileListForDataFile(), Factory.AGSEditor.CurrentGame, Factory.AGSEditor.BaseGameFileName);
}
else
{
if (!DataFileWriter.SaveThisGameToFile(AGSEditor.COMPILED_DTA_FILE_NAME, Factory.AGSEditor.CurrentGame, errors))
{
return(false);
}
string errorMsg = DataFileWriter.MakeDataFile(ConstructFileListForDataFile(), Factory.AGSEditor.CurrentGame.Settings.SplitResources * 1000000,
Factory.AGSEditor.BaseGameFileName, true);
if (errorMsg != null)
{
errors.Add(new CompileError(errorMsg));
}
}
File.Delete(AGSEditor.COMPILED_DTA_FILE_NAME);
CreateAudioVOXFile(forceRebuild);
// Update config file with current game parameters
Factory.AGSEditor.WriteConfigFile(AGSEditor.OUTPUT_DIRECTORY);
return(true);
}
static void Main(string[] args)
{
var schema = Schema.Parse(AvroSerializer.Create <Blog>().WriterSchema.ToString());
var inputs = new List <Blog>
{
new Blog {
BlogId = 101, Name = "Tanaka", Author = "One"
},
new Blog {
BlogId = 201, Name = "Sato", Author = "Two"
},
new Blog {
BlogId = 301, Name = "Suzuki", Author = "Three"
}
};
var writer = new SpecificDatumWriter <Blog>(schema);
using (var fw = DataFileWriter <Blog> .OpenWriter(writer, "./blog.avro"))
{
foreach (var blog in inputs)
{
fw.Append(blog);
}
}
var outputs = new List <Blog>();
using (var fr = DataFileReader <Blog> .OpenReader("./blog.avro"))
{
while (fr.HasNext())
{
outputs.Add(fr.Next());
}
}
foreach (var b in outputs)
{
Console.WriteLine("----- Avro → POCO 変換後 -----");
Console.WriteLine($"{b.BlogId} {b.Name} {b.Author}");
}
}
private void DeleteLocalSettings_Click(object sender, RoutedEventArgs args)
{
var currentSettings = LoadCurrentSettings;
if (currentSettings.IsDefault)
{
MessageBox.Show("現在のバックアップペアに対応するローカル設定は存在しません。", App.AssemblyName.Name, MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
if (MessageBox.Show("現在のバックアップペアに対応するローカル設定を削除します。", $"{App.AssemblyName.Name} - 確認", MessageBoxButton.OKCancel, MessageBoxImage.Warning) ==
MessageBoxResult.Cancel)
{
return;
}
DataFileWriter.Delete(currentSettings);
password.Password = PasswordManager.LoadPassword(LoadCurrentSettings) ?? string.Empty;
}
}
private void serializeAvro <T>(MemoryStream dataStream, List <SingleColumnPoco <T> > data, string schema)
{
var avroSchema = Schema.Parse(schema);
var writer = new GenericWriter <GenericRecord>(avroSchema);
var fileWriter = DataFileWriter <GenericRecord> .OpenWriter(writer, dataStream);
var encoder = new BinaryEncoder(dataStream);
foreach (SingleColumnPoco <T> record in data)
{
var genericRecord = new GenericRecord(avroSchema as RecordSchema);
genericRecord.Add("Value", record.Value);
fileWriter.Append(genericRecord);
}
fileWriter.Flush();
dataStream.Seek(0, SeekOrigin.Begin);
}
/// <summary>
/// データベースを削除するかどうかの確認ウィンドウを出してから削除する。
/// </summary>
/// <returns>削除したなら true</returns>
private bool DeleteDatabase()
{
string databasePath;
if (LoadCurrentSettings.IsUseDatabase && File.Exists(databasePath = DataFileWriter.GetDatabasePath(originPath.Text, destPath.Text)))
{
var deleteDatabase = MessageBox.Show($"{databasePath}\n上記データベースを削除しますか？", $"{App.AssemblyName.Name} - 確認", MessageBoxButton.YesNo);
switch (deleteDatabase)
{
case MessageBoxResult.Yes:
DataFileWriter.DeleteDatabase(originPath.Text, destPath.Text);
MessageBox.Show("データベースを削除しました。");
return(true);
case MessageBoxResult.No:
default:
return(false);
}
}
return(false);
}
private static void BuildDataFileWriter(string outputFilePath, Mode mode)
{
GenericDatumWriter <GenericRecord> datumWriter = new GenericDatumWriter <GenericRecord>(_avroSchema);
Codec codec = Codec.CreateCodec(Codec.Type.Deflate);
switch (mode)
{
case Mode.Overwrite:
_dataFileWriter = (DataFileWriter <GenericRecord>) DataFileWriter <GenericRecord> .OpenWriter(
datumWriter, new FileStream(outputFilePath, FileMode.Create), codec);
break;
case Mode.Append:
_dataFileWriter = (DataFileWriter <GenericRecord>) DataFileWriter <GenericRecord> .OpenWriter(
datumWriter, new FileStream(outputFilePath, FileMode.Append), codec);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode));
}
}
private void serializeAvro <T>(MemoryStream dataStream, List <T> data, string schema)
{
var avroSchema = Schema.Parse(schema);
var writer = new GenericWriter <GenericRecord>(avroSchema);
var fileWriter = DataFileWriter <GenericRecord> .OpenWriter(writer, dataStream);
var encoder = new BinaryEncoder(dataStream);
foreach (T record in data)
{
var genericRecord = new GenericRecord(avroSchema as RecordSchema);
foreach (var prop in typeof(T).GetProperties())
{
genericRecord.Add(prop.Name, prop.GetValue(record));
}
fileWriter.Append(genericRecord);
}
fileWriter.Flush();
dataStream.Seek(0, SeekOrigin.Begin);
}
public static void Run()
{
Console.WriteLine("Running GenericRecord example");
using (var stream = File.OpenWrite(@"users.avro"))
{
var schemaJson = "{\"type\" : \"record\", " +
"\"namespace\" : \"myNameSpace\", " +
"\"name\" : \"User\", " +
"\"fields\" : " +
"[" +
"{ \"name\" : \"Name\" , \"type\" : \"string\" }," +
"{ \"name\" : \"ID\" , \"type\" : \"int\" }]}";
var recordSchema = (RecordSchema)Schema.Parse(schemaJson);
using (var writer = DataFileWriter <GenericRecord> .OpenWriter(new GenericDatumWriter <GenericRecord>(recordSchema), stream))
{
var record = new GenericRecord(recordSchema);
record.Add(0, "user1");
record.Add(1, 1234);
writer.Append(record);
}
}
using (var stream = File.OpenRead(@"users.avro"))
{
using (var reader = DataFileReader <GenericRecord> .OpenReader(stream, null, (ws, rs) => new GenericDatumReader <GenericRecord>(ws, rs)))
{
PrintHeader(reader);
foreach (var entry in reader.NextEntries)
{
Print(entry);
}
}
}
}
