vous pouvez utiliser ce qui suit pour publier une chaîne dans le champ varbinary

public string ReadCString(byte[] cString)
        {
            var nullIndex = Array.IndexOf(cString, (byte)0);
            nullIndex = (nullIndex == -1) ? cString.Length : nullIndex;
            return System.Text.Encoding.Unicode.GetString(cString);
        }

puis utiliser ce qui suit pour récupérer les données sous forme de chaîne

Encoding.Unicode.GetBytes(Item.VALUE)

Astuce pour modifier la table

J'essayais de proposer une approche utilisant le classement Utf8 de SQL Server 2019 et j'ai trouvé jusqu'à présent une méthode possible, qui devrait être plus rapide que l'astuce XML (voir ci-dessous). p >

1. Créez une table temporaire avec une colonne varbinary.
2. Insérer des valeurs varbinary dans le tableau
3. Modifier la table modifier la colonne en varchar avec le classement utf8

(cette parenthèse sert à séparer la liste numérotée du code formaté)

DECLARE @LongText NVARCHAR(MAX) = N'...<s>o</s>o&amp;me lo>>>ng u>n<<i< &&code text...';
DECLARE @StartXML DATETIME2(7), @EndXML DATETIME2(7), @StartTable DATETIME2(7), @EndTable DATETIME2(7);

drop table if exists
  #longTexts,
  #longBinaries,
  #XMLConverts;
create table #longTexts (LongText VARCHAR(MAX) COLLATE Czech_100_CI_AI_SC_UTF8 NOT NULL);
create table #longBinaries (LongBinary VARBINARY(MAX) NOT NULL);
CREATE TABLE #XMLConverts (LongText VARCHAR(MAX) COLLATE Czech_100_CI_AI_SC_UTF8 NOT NULL);

insert into #longTexts --make the long text longer
  (LongText)
select
  REPLICATE(@LongText, 100000)
from 
  Data0001.dbo.Numbers --use while if you don't have number table
WHERE
  Number BETWEEN 1 AND 100; --make more of them

insert into #longBinaries (LongBinary) select CAST(LongText AS varbinary(max)) from #longTexts;

SET @StartXML = SYSDATETIME();
------------------------------
--MEASURE XML--
INSERT INTO #XMLConverts 
  (
    LongText
  )
SELECT
  CAST(
    '<?xml version=''1.0'' encoding=''utf-8''?>' +
    REPLACE(
      REPLACE(
        LB.LongBinary,
        '&',
        '&amp;'
      ),
      '<',
      '&lt;'
    ) AS XML
  ).value('.', 'varchar(max)')
FROM
  #longBinaries AS LB;
SET @EndXML = SYSDATETIME();

SET @StartTable = SYSDATETIME();
--------------------------------------------
--MEASURE ALTER TABLE--
DROP TABLE IF EXISTS #AlterConverts;
CREATE TABLE #AlterConverts (UTF8 VARBINARY(MAX));

INSERT INTO #AlterConverts 
  (
    UTF8
  )
SELECT
  LB.LongBinary
FROM
  #longBinaries AS LB;

ALTER TABLE #AlterConverts ALTER COLUMN UTF8 VARCHAR(MAX) COLLATE Czech_100_CI_AI_SC_UTF8;
--ALTER TABLE #AlterConverts ALTER COLUMN UTF8 NVARCHAR(MAX);

SET @EndTable = SYSDATETIME();

SELECT
  DATEDIFF(MILLISECOND, @StartXML, @EndXML) AS XML_MS,
  DATEDIFF(MILLISECOND, @StartTable, @EndTable) AS ALTER_MS;

Astuce XML

La solution suivante devrait fonctionner pour tout encodage.

Il existe une manière délicate de faire exactement ce que l'OP demande. Edit: J'ai trouvé la même méthode discutée sur SO ( SQL - UTF-8 à varchar / nvarchar Encoding issue )

Le processus se déroule comme suit:

SELECT
  CAST(
    '<?xml version=''1.0'' encoding=''utf-8''?>' +
    REPLACE(
      REPLACE(
        @BinaryValue,
        '&',
        '&amp;'
      ),
      '<',
      '&lt;'
    ) AS XML
  ).value('.', 'varchar(max)')

Pourquoi cela fonctionne: varbinary et varchar sont la même chaîne de bits - seule l'interprétation diffère, donc le xml résultant est vraiment un train de bits encodé en utf8 et l'interpréteur xml est alors capable de reconstruire les caractères encodés en utf8 corrects.

Différence de vitesse

La vitesse la différence varie considérablement en fonction des données. Lorsqu'il y a beaucoup à remplacer lors de l'utilisation de astuce XML , l ' astuce ALTER peut être beaucoup, beaucoup plus rapide. Lorsqu'il y a peu de textes ou si les textes sont courts, la surcharge liée à la création et à la modification d'une table temporaire entraînera une surcharge importante. Donc: "Cela dépend ..."

drop table if exists
  #bin,
  #utf8;

create table #utf8 (UTF8 VARCHAR(MAX) COLLATE Czech_100_CI_AI_SC_UTF8);
create table #bin (BIN VARBINARY(MAX));

insert into #utf8 (UTF8) values ('Žluťoučký kůň říčně pěl ďábelské ódy za svitu měsíce.');
insert into #bin (BIN) select CAST(UTF8 AS varbinary(max)) from #utf8;

select * from #utf8; --here you can see the utf8 string is stored correctly and that
select BIN, CAST(BIN AS VARCHAR(MAX)) from #bin; --utf8 binary is converted into gibberish

alter table #bin alter column BIN varchar(max) collate Czech_100_CI_AI_SC_UTF8;
select * from #bin; --voialá, correctly converted varchar

alter table #bin alter column BIN nvarchar(max);
select * from #bin; --finally, correctly converted nvarchar