/// <summary>
/// Convertit les métadonnées provenant de acoustid en Metadatas.
/// </summary>
/// <param name="metadatasItunes">Métadonnées provenant d'Acoustid</param>
/// <returns>Status peut valoir : NeedValidation, NoResult.</returns>
override protected Metadatas convertToMetadatas(MetadatasAcoustid metadatasAcoustid)
{
Metadatas metadatas = new Metadatas();
metadatas.Valid = false;
if (metadatasAcoustid.results.Count != 0 &&
metadatasAcoustid.results[0].recordings.Count != 0 &&
metadatasAcoustid.results[0].recordings[0].releasegroups.Count != 0 &&
metadatasAcoustid.results[0].recordings[0].releasegroups[0].releases.Count != 0 &&
metadatasAcoustid.results[0].recordings[0].releasegroups[0].releases[0].mediums.Count != 0 &&
metadatasAcoustid.results[0].recordings[0].releasegroups[0].releases[0].mediums[0].tracks.Count != 0 &&
metadatasAcoustid.results[0].recordings[0].releasegroups[0].releases[0].mediums[0].tracks[0].artists.Count != 0)
{
metadatas.AlbumName = "";
metadatas.ArtistName = metadatasAcoustid.results[0].recordings[0].releasegroups[0].releases[0].mediums[0].tracks[0].artists[0].name;
metadatas.ReleaseDate = "";
metadatas.Title = metadatasAcoustid.results[0].recordings[0].releasegroups[0].releases[0].mediums[0].tracks[0].title;
metadatas.checkValidity();
}
else
{
metadatas.Status = Status.NoResult;
}
return(metadatas);
}
/// <summary>
/// Convertit les métadonnées provenant d'Itunes en Metadatas.
/// </summary>
/// <param name="metadatasItunes">Métadonnées provenant d'Itunes</param>
/// <returns>Status peut valoir : NeedValidation, NoResult.</returns>
override protected Metadatas convertToMetadatas(MetadatasItunes metadatasItunes)
{
Metadatas metadatas = new Metadatas();
metadatas.Valid = false;
if (metadatasItunes.resultCount != 0)
{
metadatas.AlbumName = metadatasItunes.results.First().collectionName;
metadatas.ArtistName = metadatasItunes.results.First().artistName;
DateTime tmpDate = Convert.ToDateTime(metadatasItunes.results.First().releaseDate);
metadatas.ReleaseDate = tmpDate.Year.ToString();
metadatas.Title = metadatasItunes.results.First().trackName;
metadatas.AlbumCoverStream = GetStreamFromUrl(metadatasItunes.results.First().artworkUrl100);
metadatas.AlbumCover = GetBitmapImageFromStream(metadatas.AlbumCoverStream);
metadatas.AlbumCoverDisplay = metadatas.AlbumCover as BitmapSource;
metadatas.checkValidity();
}
else
{
metadatas.Status = Status.NoResult;
}
return(metadatas);
}
public void Execute(IDbConnection connection, Metadatas metadata, ExecutionPlan plan)
{
var query = new StringBuilder();
var cmd = connection.CreateCommand();
var nbParams = 0;
connection.Open();
using (var transaction = connection.BeginTransaction())
{
var cancel = false;
foreach (var step in plan.InsertSteps)
{
GemerateInsertStatment(metadata, step, cmd, query, transaction, ref nbParams);
TryExecute(connection, plan, query, transaction, ref cmd, ref nbParams, ref cancel);
}
foreach (var step in plan.UpdateSteps)
{
GemerateUpdateStatment(step, cmd, query);
TryExecute(connection, plan, query, transaction, ref cmd, ref nbParams, ref cancel);
}
//Flush
Execute(plan, query, transaction, cmd, ref cancel);
if (!cancel)
{
transaction.Commit();
}
}
connection.Close();
}
private static void fill_metadata(GenBankMetadata metadata, long id)
{
//codes to add data here
Metadatas met = new Metadatas(metadata, id);
MySqlCommand cmmd3 = new MySqlCommand(met.get_query(), conn);
MySqlDataReader reader3 = cmmd3.ExecuteReader();
reader3.Close();
long metadata_id = cmmd3.LastInsertedId;
fill_locus(metadata.Locus, metadata_id);
fill_version(metadata.Version, metadata_id);
fill_source(metadata.Source, metadata_id);
foreach (var s in metadata.Accession.Secondary)
{
fill_secondary_accession(s.ToString(), metadata_id);
}
foreach (var c in metadata.Comments)
{
fill_comment(c.ToString(), metadata_id);
}
foreach (var d in metadata.DbLinks)
{
fill_dblink(d, metadata_id);
}
foreach (var r in metadata.References)
{
fill_reference(r, metadata_id);
}
foreach (var f in metadata.Features.All)
{
fill_feature(f, metadata_id);
}
}
private void Init()
{
if(this.holder == null) { this.holder = Getters4Editor.GetHolder(); }
this.metadatas = new Metadatas(this.holder.metadatas);
this.titleContent.text = "Select Template";
this.titleContent.tooltip = "Select Template Window";
}
/// <summary>
/// 获取一个元数据
/// </summary>
/// <typeparam name="T">元数据类型</typeparam>
/// <param name="name">元数据名称</param>
/// <param name="def">如果指定名称的元数据不存在则返回这个参数</param>
/// <returns>元数据值</returns>
public T GetMetadata <T>(string name, T def = default(T))
{
if (!Metadatas.ContainsKey(name))
{
return(def);
}
return((T)Metadatas[name]);
}
override public Metadatas search(Metadatas metadatasFromMusique)
{
string recherche = "&q_track=" + escape(Tools.UpperFirstLetters(metadatasFromMusique.ArtistName) + "-" + @metadatasFromMusique.Title);
Metadatas metadatas;
metadatas = request(recherche);
return(metadatas);
}
/// <summary>
/// Add a new metadata entry (with event.)
/// </summary>
public void AddMetadata(urakawa.metadata.Metadata entry)
{
Metadatas.Insert(Metadatas.Count, entry);
//sdk2 addMetadata(entry);
//sdk2-todo use SDK 2.0 events
if (MetadataEntryAdded != null)
{
MetadataEntryAdded(this, new MetadataEventArgs(entry));
}
}
override public Metadatas search(Metadatas metadatasFromMusique)
{
string recherche = "duration=" + metadatasFromMusique.Duration
+ "&fingerprint=" + metadatasFromMusique.Fingerprint;
Metadatas metadatas;
metadatas = request(recherche);
return(metadatas);
}
private void SetMetadata(Metadatas metadata, string value)
{
if (!VlcContext.HandleManager.MediasHandles.ContainsKey(myHostMediaBase))
{
return;
}
VlcContext.InteropManager.MediaInterops.SetMetadata.Invoke(
VlcContext.HandleManager.MediasHandles[myHostMediaBase],
metadata,
value);
}
/// <summary>
/// Delete a metadata entry (with event.)
/// </summary>
public void DeleteMetadata(urakawa.metadata.Metadata entry)
{
Metadatas.Remove(entry);
//sdk2 deleteMetadata(entry);
//sdk2-todo use SDK 2.0 events
if (MetadataEntryDeleted != null)
{
MetadataEntryDeleted(this, new MetadataEventArgs(entry));
}
}
public string GetMetadata(string metadataName)
{
if (Metadatas == null)
{
return(null);
}
if (Metadatas.ContainsKey(metadataName))
{
return(Metadatas[metadataName]);
}
return(null);
}
public XS__RootMetadata(
#endif
string metadataFilePath_in
)
{
string _metadataPath = System.IO.Path.GetDirectoryName(metadataFilePath_in);
this.metadatafiles_ = Metadatas.Load_fromFile(metadataFilePath_in);
#region int _total_xxx = ...;
int _total_documentation = 0;
for (int f = 0; f < this.metadatafiles_.MetadataFiles.Count; f++)
{
switch (this.metadatafiles_.MetadataFiles[f].XMLFileType)
{
case XS__documentation.DOCUMENTATION:
_total_documentation++;
break;
}
}
#endregion
#region string[] _xxxFilePath = new string[_total_xxx];
string[] _documentationFilePath = new string[
_total_documentation
];
#endregion
_total_documentation = 0;
for (int f = 0; f < this.metadatafiles_.MetadataFiles.Count; f++)
{
switch (this.metadatafiles_.MetadataFiles[f].XMLFileType)
{
case XS__documentation.DOCUMENTATION:
_documentationFilePath[_total_documentation] = System.IO.Path.Combine(
_metadataPath,
this.metadatafiles_.MetadataFiles[f].XMLFileName
);
_total_documentation++;
break;
}
}
this.documentationcollection_ = new XS__documentationCollection(
XS__documentation.Load_fromFile(
(XS__RootMetadata)this,
_documentationFilePath
)
);
}
public XS__RootMetadata(
#endif
string metadataFilePath_in
)
{
string _metadataPath = System.IO.Path.GetDirectoryName(metadataFilePath_in);
this.metadatafiles_ = Metadatas.Load_fromFile(metadataFilePath_in);
#region int _total_xxx = ...;
int _total_spreadsheet = 0;
for (int f = 0; f < this.metadatafiles_.MetadataFiles.Count; f++)
{
switch (this.metadatafiles_.MetadataFiles[f].XMLFileType)
{
case XS__spreadsheet.SPREADSHEET:
_total_spreadsheet++;
break;
}
}
#endregion
#region string[] _xxxFilePath = new string[_total_xxx];
string[] _spreadsheetFilePath = new string[
_total_spreadsheet
];
#endregion
_total_spreadsheet = 0;
for (int f = 0; f < this.metadatafiles_.MetadataFiles.Count; f++)
{
switch (this.metadatafiles_.MetadataFiles[f].XMLFileType)
{
case XS__spreadsheet.SPREADSHEET:
_spreadsheetFilePath[_total_spreadsheet] = System.IO.Path.Combine(
_metadataPath,
this.metadatafiles_.MetadataFiles[f].XMLFileName
);
_total_spreadsheet++;
break;
}
}
this.spreadsheetcollection_ = new XS__spreadsheetCollection(
XS__spreadsheet.Load_fromFile(
(XS__RootMetadata)this,
_spreadsheetFilePath
)
);
}
public XS__RootMetadata(
#endif
string metadataFilepath_in
)
{
string _metadataPath = System.IO.Path.GetDirectoryName(metadataFilepath_in);
metadatafiles_ = Metadatas.Load_fromFile(metadataFilepath_in);
#region int _total_xxx = ...;
int _total_diagram = 0;
for (int f = 0; f < metadatafiles_.MetadataFiles.Count; f++)
{
switch (metadatafiles_.MetadataFiles[f].XMLFileType)
{
case XS__diagram.DIAGRAM:
_total_diagram++;
break;
}
}
#endregion
#region string[] _xxxFilepath = new string[_total_xxx];
string[] _diagramFilepath = new string[
_total_diagram
];
#endregion
_total_diagram = 0;
for (int f = 0; f < metadatafiles_.MetadataFiles.Count; f++)
{
switch (metadatafiles_.MetadataFiles[f].XMLFileType)
{
case XS__diagram.DIAGRAM:
_diagramFilepath[_total_diagram] = System.IO.Path.Combine(
_metadataPath,
metadatafiles_.MetadataFiles[f].XMLFilename
);
_total_diagram++;
break;
}
}
diagramcollection_ = new XS__diagramCollection(
XS__diagram.Load_fromFile(
(XS__RootMetadata)this,
_diagramFilepath
)
);
}
protected override void InnerInit(IFixture fixture)
{
base.InnerInit(fixture);
var metadataWithDuplicateField =
fixture.Build <TemplateCodeGenerationMetadata>()
.FromFactory(() => new TemplateCodeGenerationMetadata
(fixture.Create <TemplateInfo>(),
fixture.Create <string>(),
fixture.Create <string>(),
Metadata.OwnFields))
.WithAutoProperties()
.Create();
Metadata.BaseTemplates.Add(metadataWithDuplicateField);
Metadatas.Add(metadataWithDuplicateField);
}
public void Initialize(List <Connection> connectionsString, Metadatas metadatas)
{
Connections.Clear();
foreach (var conn in connectionsString)
{
var dbConnection = DbProviderFactories.GetFactory(conn.ProviderName).CreateConnection();
dbConnection.ConnectionString = conn.ConnectionString;
Connections.Add(conn,
new ConnectionContext(dbConnection,
QueryProviderFactory.GetProvider(conn.ProviderName)));
}
Metadatas = metadatas;
}
public static Query Load(string path)
{
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
int formatVersion;
string description;
HashSet <Connection> connections;
Metadatas metadata;
ExecutionPlanByServer executionPlanByServer;
FastAccessList <object> referenceTracking;
//using (var istream = new FileStream(path, FileMode.Open))
//using (var lzstream = new LZ4Stream(istream, CompressionMode.Decompress))
//using (var bstream = new BinaryReader(lzstream, Encoding.UTF8, true))
//{
// formatVersion = bstream.ReadInt32();
// description = bstream.ReadString();
// referenceTracking = DeserializeReferenceTracking(bstream);
// connections = DeserializeConnections(bstream);
// executionPlanByServer = ExecutionPlanByServer.Deserialize(bstream, referenceTracking);
// metadata = AppMetadata.Deserialize(bstream, referenceTracking);
//}
using (var istream = new FileStream(path, FileMode.Open))
using (var bstream = new BinaryReader(istream, Encoding.UTF8, true))
{
formatVersion = bstream.ReadInt32();
description = bstream.ReadString();
referenceTracking = DeserializeReferenceTracking(bstream);
connections = DeserializeConnections(bstream);
executionPlanByServer = ExecutionPlanByServer.Deserialize(bstream, referenceTracking);
metadata = Metadatas.Deserialize(bstream, referenceTracking);
}
//Initialize a connection context with values used at the time of the creation of the clone.
var connectionsContext = new ConnectionsContext();
connectionsContext.Initialize(connections.ToList(), metadata);
return(new Query(connectionsContext, executionPlanByServer, formatVersion)
{
Description = description
});
}
public void LoadForeignKeys(IDbConnection connection, Metadatas metadata, string serverId, string database)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = SqlGetForeignKeys;
var p = cmd.CreateParameter();
p.ParameterName = SqlWriter.NamedParamPrefix + "DATABASE";
p.Value = database;
cmd.Parameters.Add(p);
connection.Open();
using (var r = cmd.ExecuteReader())
MetadataLoader.LoadForeignKeys(r, metadata, serverId, database);
connection.Close();
}
}
private static void DeserializeBody(BinaryReader input,
ref Metadatas metadatas,
FastAccessList <object> referenceTracking = null)
{
//var nbServerMap = input.ReadInt32();
//for (var i = 0; i < nbServerMap; i++)
//{
// var src = SehemaIdentifier.Deserialize(input);
// var dst = SehemaIdentifier.Deserialize(input);
// config.Map.Add(src, dst);
//}
//var nbConnection = input.ReadInt32();
//for (var i = 0; i < nbConnection; i++)
// config.ConnectionStrings.Add(SqlConnection.Deserialize(input));
metadatas = Metadatas.Deserialize(input, referenceTracking);
}
/// <summary>
/// Convertit les métadonnées provenant de MusixMatch en Metadatas.
/// </summary>
/// <param name="metadatasMusixmatch">Métadonnées provenant de MusixMatch</param>
/// <returns>Status peut valoir : NeedValidation, NoResult.</returns>
/// <returns></returns>
override protected Metadatas convertToMetadatas(MetadatasMusixmatch metadatasMusixmatch)
{
Metadatas metadatas = new Metadatas();
if ((metadatasMusixmatch != null) && (metadatasMusixmatch.Track != null))
{
metadatas.AlbumName = metadatasMusixmatch.Track.album_name;
metadatas.ArtistName = metadatasMusixmatch.Track.artist_name;
metadatas.ReleaseDate = metadatasMusixmatch.Track.first_release_date;
metadatas.Title = metadatasMusixmatch.Track.track_name;
metadatas.checkValidity();
}
else
{
metadatas.Status = Status.NoResult;
}
return(metadatas);
}
private void InitExecutionContext(Project project, Configuration.Environment sourceEnvir,
Configuration.Environment destinationEnvir,
string configFileHash, Metadatas metadatas = null)
{
ExecutionContextCacheHash = configFileHash;
//Init connection strings
ConnectionsContext.Initialize(project.ConnectionStrings, metadatas);
//Init maps
if (sourceEnvir == null || sourceEnvir.Schemas == null)
{
return;
}
foreach (var sourceSchema in sourceEnvir.Schemas)
{
var destinationSchema = destinationEnvir.Schemas.FirstOrDefault(s => s.Id == sourceSchema.Id);
if (destinationSchema == null)
{
throw new Exception($"The destination schema {sourceSchema.Id} is not found in the environment {destinationEnvir.Name}. Please declare it.");
}
var source = new SehemaIdentifier
{
ServerId = sourceSchema.Server,
Database = sourceSchema.Database,
Schema = sourceSchema.Schema
};
var destination = new SehemaIdentifier
{
ServerId = destinationSchema.Server,
Database = destinationSchema.Database,
Schema = destinationSchema.Schema
};
if (!Map.ContainsKey(source))
{
Map.Add(source, destination);
}
}
}
/// <summary>
/// Produce a <see cref="Query"/> that can be executed, saved and loaded endlessly.
/// </summary>
/// <returns>An executable query.</returns>
public Query Compile()
{
OptimizeExecutionPlans(_executionPlanByServer);
//Purify
var conns = new List <Connection>();
var metadata = new Metadatas();
var destinationSrv = (from server in _executionPlanByServer
from insertStep in server.Value.InsertSteps
select insertStep.DestinationTable.ServerId).Distinct();
foreach (var srv in destinationSrv)
{
conns.Add(ConnectionsContext.Connections.Keys.First(c => c.Id == srv));
metadata.Add(srv, Metadatas.First(s => s.Key == srv).Value);
}
return(new Query(ConnectionsContext, _executionPlanByServer, Query.CurrentFormatVersion));
}
public IMetadatas GetMetadataByAttr(Type sourceType)
{
var ret = new Metadatas();
this.ParseAttr(sourceType.GetCustomAttributes(true), ret);
//var s = this.getIdName(sourceType);
// Теперяча надо перебрать атрибуты полей
var props = sourceType.GetProperties();
foreach (var p in props)
{
this.AddFieldsInfo(p, ret); //Metadata of Fields and types
this.ParseAttr(p.GetCustomAttributes(true), ret, p.Name, FieldAtributeToRootList);
this.AddFieldIdInfo(p.Name, ret);
}
return(ret);
}
/// <summary>
/// Gets media metadata
/// </summary>
/// <param name="metadata">Media property</param>
/// <returns>Metadata value</returns>
private string GetMetadata(Metadatas metadata)
{
if (!VlcContext.HandleManager.MediasHandles.ContainsKey(myHostMediaBase))
{
return(null);
}
if (VlcContext.InteropManager.MediaInterops.IsParsed.Invoke(VlcContext.HandleManager.MediasHandles[myHostMediaBase]) == 0)
{
VlcContext.InteropManager.MediaInterops.Parse.Invoke(VlcContext.HandleManager.MediasHandles[myHostMediaBase]);
}
try
{
return(IntPtrExtensions.ToStringAnsi(VlcContext.InteropManager.MediaInterops.GetMetadata.Invoke(
VlcContext.HandleManager.MediasHandles[myHostMediaBase],
metadata)));
}
catch
{
return(null);
}
}
public object[][] Select(IDbConnection connection, Metadatas metadata, RowIdentifier row)
{
var rows = new List <object[]>();
var tableMetadata = metadata.GetTable(row);
var nbParams = row.Columns.Count;
var selectWriter = SqlWriter.GetSelectWriter()
.AppendColumns(row, tableMetadata.ColumnsDefinition);
using (var cmd = connection.CreateCommand())
{
//Build query / params
for (var i = 0; i < nbParams; i++)
{
var colName = row.Columns.ElementAt(i).Key;
var paramName = SqlWriter.NamedParamPrefix + colName;
var p = cmd.CreateParameter();
p.ParameterName = paramName;
p.Value = row.Columns.ElementAt(i).Value;
cmd.Parameters.Add(p);
selectWriter.AppendToWhere(colName, paramName);
}
cmd.CommandText = selectWriter.ToStringBuilder().ToString();
//Exec query
connection.Open();
using (var r = cmd.ExecuteReader())
{
while (r.Read())
{
var values = new object[r.FieldCount];
r.GetValues(values);
rows.Add(values);
}
}
connection.Close();
}
return(rows.ToArray());
}
public override bool Equals(object obj)
{
var model = obj as ServiceRouteDescriptor;
if (model == null)
{
return(false);
}
if (obj.GetType() != GetType())
{
return(false);
}
if (model.Id != Id)
{
return(false);
}
return(model.Metadatas.Count == Metadatas.Count && model.Metadatas.All(metadata =>
{
object value;
if (!Metadatas.TryGetValue(metadata.Key, out value))
{
return false;
}
if (metadata.Value == null && value == null)
{
return true;
}
if (metadata.Value == null || value == null)
{
return false;
}
return metadata.Value.Equals(value);
}));
}
public override bool Equals(object obj)
{
var other = obj as Document;
if (Name != other.Name ||
User.Name != other.User.Name ||
Content != other.Content ||
IndexNodes != other.IndexNodes ||
IndexLeaves != other.IndexLeaves ||
UserName != other.UserName)
{
return(false);
}
if (!NoMetadata &&
!other.NoMetadata &&
Metadatas.Count(m => m.Get(this) != null) > 1 &&
Metadatas.Count(m => m.Get(other) != null) > 1 &&
(Id != other.Id || Index != other.Index))
{
return(false);
}
if (Children?.Count != other.Children?.Count)
{
return(false);
}
if (Children != null)
{
foreach (var document in Children)
{
var otherDocument = other.Children?.SingleOrDefault(o => o.Name == document.Name);
if (otherDocument == null || !document.Equals(otherDocument))
{
return(false);
}
}
}
return(true);
}
//TODO: change to property
public List <string> GetNamespaces()
{
var namespaces = new List <string>();
namespaces.AddRange(
Metadatas.Select(m => m.Namespace).SelectMany(a => a).ToList());
namespaces.AddRange(
Properties.Select(p => p.Namespaces).SelectMany(a => a).ToList());
if (BaseType != null)
{
namespaces.Add(BaseType.Namespace);
}
namespaces.AddRange(
InterfaceTypes.Select(i => i.Namespace));
namespaces.AddRange(
Enums.Select(e => e.Namespace));
return(namespaces.Distinct().ToList());
}
/// <summary>
/// Envoie une requête à l'API pour récupérer les métadatas à partir d'une recherche
/// </summary>
/// <param name="recherche">Peut être un nom de musique, d'artiste,...</param>
/// <returns>Status peut valoir : NeedValidation, NoConnection, NoResult.</returns>
protected Metadatas request(string search)
{
Metadatas metadatas;
WebResponse response;
// Create a request for the URL.
WebRequest request = WebRequest.Create(_url + "?" + _parameters + "&" + search);
try
{
string responseFromServer = "";
// Get the response.
response = request.GetResponse();
// Get the stream containing content returned by the server.
Stream dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
responseFromServer = reader.ReadToEnd();
// Clean up the streams and the response.
reader.Close();
response.Close();
metadatas = convertToMetadatas(JsonConvert.DeserializeObject <T>(responseFromServer));
}
catch
{
// Si l'API n'a pas pu être contactée
metadatas = new Metadatas();
metadatas.Status = Status.NoConnetion;
}
metadatas.Source = Source;
return(metadatas);
}
public static TableMetadata GetTable(this Metadatas metadatas, DerivativeTable dt)
{
return(metadatas.GetTable(dt.ServerId, dt.Database, dt.Schema, dt.Table));
}
/// <summary>
/// Gets media metadata
/// </summary>
/// <param name="metadata">Media property</param>
/// <returns>Metadata value</returns>
private string GetMetadata(Metadatas metadata)
{
if (!VlcContext.HandleManager.MediasHandles.ContainsKey(myHostMediaBase))
return null;
if (VlcContext.InteropManager.MediaInterops.IsParsed.Invoke(VlcContext.HandleManager.MediasHandles[myHostMediaBase]) == 0)
VlcContext.InteropManager.MediaInterops.Parse.Invoke(VlcContext.HandleManager.MediasHandles[myHostMediaBase]);
try
{
return IntPtrExtensions.ToStringAnsi(VlcContext.InteropManager.MediaInterops.GetMetadata.Invoke(
VlcContext.HandleManager.MediasHandles[myHostMediaBase],
metadata));
}
catch
{
return null;
}
}
private void SetMetadata(Metadatas metadata, string value)
{
if (!VlcContext.HandleManager.MediasHandles.ContainsKey(myHostMediaBase))
return;
VlcContext.InteropManager.MediaInterops.SetMetadata.Invoke(
VlcContext.HandleManager.MediasHandles[myHostMediaBase],
metadata,
value);
}
